Note when new HTLC state can be `None`
[rust-lightning] / lightning / src / ln / channel.rs
1 // This file is Copyright its original authors, visible in version control
2 // history.
3 //
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
8 // licenses.
9
10 use bitcoin::blockdata::constants::ChainHash;
11 use bitcoin::blockdata::script::{Script, ScriptBuf, Builder};
12 use bitcoin::blockdata::transaction::Transaction;
13 use bitcoin::sighash;
14 use bitcoin::sighash::EcdsaSighashType;
15 use bitcoin::consensus::encode;
16
17 use bitcoin::hashes::Hash;
18 use bitcoin::hashes::sha256::Hash as Sha256;
19 use bitcoin::hashes::sha256d::Hash as Sha256d;
20 use bitcoin::hash_types::{Txid, BlockHash};
21
22 use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE;
23 use bitcoin::secp256k1::{PublicKey,SecretKey};
24 use bitcoin::secp256k1::{Secp256k1,ecdsa::Signature};
25 use bitcoin::secp256k1;
26
27 use crate::ln::{ChannelId, PaymentPreimage, PaymentHash};
28 use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
29 use crate::ln::msgs;
30 use crate::ln::msgs::DecodeError;
31 use crate::ln::script::{self, ShutdownScript};
32 use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT, ChannelShutdownState};
33 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};
34 use crate::ln::chan_utils;
35 use crate::ln::onion_utils::HTLCFailReason;
36 use crate::chain::BestBlock;
37 use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, LowerBoundedFeeEstimator};
38 use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, LATENCY_GRACE_PERIOD_BLOCKS, CLOSED_CHANNEL_UPDATE_ID};
39 use crate::chain::transaction::{OutPoint, TransactionData};
40 use crate::sign::ecdsa::{EcdsaChannelSigner, WriteableEcdsaChannelSigner};
41 use crate::sign::{EntropySource, ChannelSigner, SignerProvider, NodeSigner, Recipient};
42 use crate::events::ClosureReason;
43 use crate::routing::gossip::NodeId;
44 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
45 use crate::util::logger::{Logger, Record, WithContext};
46 use crate::util::errors::APIError;
47 use crate::util::config::{UserConfig, ChannelConfig, LegacyChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits, MaxDustHTLCExposure};
48 use crate::util::scid_utils::scid_from_parts;
49
50 use crate::io;
51 use crate::prelude::*;
52 use core::{cmp,mem,fmt};
53 use core::convert::TryInto;
54 use core::ops::Deref;
55 #[cfg(any(test, fuzzing, debug_assertions))]
56 use crate::sync::Mutex;
57 use crate::sign::type_resolver::ChannelSignerType;
58
59 use super::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint};
60
61 #[cfg(test)]
62 pub struct ChannelValueStat {
63         pub value_to_self_msat: u64,
64         pub channel_value_msat: u64,
65         pub channel_reserve_msat: u64,
66         pub pending_outbound_htlcs_amount_msat: u64,
67         pub pending_inbound_htlcs_amount_msat: u64,
68         pub holding_cell_outbound_amount_msat: u64,
69         pub counterparty_max_htlc_value_in_flight_msat: u64, // outgoing
70         pub counterparty_dust_limit_msat: u64,
71 }
72
73 pub struct AvailableBalances {
74         /// The amount that would go to us if we close the channel, ignoring any on-chain fees.
75         pub balance_msat: u64,
76         /// Total amount available for our counterparty to send to us.
77         pub inbound_capacity_msat: u64,
78         /// Total amount available for us to send to our counterparty.
79         pub outbound_capacity_msat: u64,
80         /// The maximum value we can assign to the next outbound HTLC
81         pub next_outbound_htlc_limit_msat: u64,
82         /// The minimum value we can assign to the next outbound HTLC
83         pub next_outbound_htlc_minimum_msat: u64,
84 }
85
86 #[derive(Debug, Clone, Copy, PartialEq)]
87 enum FeeUpdateState {
88         // Inbound states mirroring InboundHTLCState
89         RemoteAnnounced,
90         AwaitingRemoteRevokeToAnnounce,
91         // Note that we do not have a AwaitingAnnouncedRemoteRevoke variant here as it is universally
92         // handled the same as `Committed`, with the only exception in `InboundHTLCState` being the
93         // distinction of when we allow ourselves to forward the HTLC. Because we aren't "forwarding"
94         // the fee update anywhere, we can simply consider the fee update `Committed` immediately
95         // instead of setting it to AwaitingAnnouncedRemoteRevoke.
96
97         // Outbound state can only be `LocalAnnounced` or `Committed`
98         Outbound,
99 }
100
101 enum InboundHTLCRemovalReason {
102         FailRelay(msgs::OnionErrorPacket),
103         FailMalformed(([u8; 32], u16)),
104         Fulfill(PaymentPreimage),
105 }
106
107 enum InboundHTLCState {
108         /// Offered by remote, to be included in next local commitment tx. I.e., the remote sent an
109         /// update_add_htlc message for this HTLC.
110         RemoteAnnounced(PendingHTLCStatus),
111         /// Included in a received commitment_signed message (implying we've
112         /// revoke_and_ack'd it), but the remote hasn't yet revoked their previous
113         /// state (see the example below). We have not yet included this HTLC in a
114         /// commitment_signed message because we are waiting on the remote's
115         /// aforementioned state revocation. One reason this missing remote RAA
116         /// (revoke_and_ack) blocks us from constructing a commitment_signed message
117         /// is because every time we create a new "state", i.e. every time we sign a
118         /// new commitment tx (see [BOLT #2]), we need a new per_commitment_point,
119         /// which are provided one-at-a-time in each RAA. E.g., the last RAA they
120         /// sent provided the per_commitment_point for our current commitment tx.
121         /// The other reason we should not send a commitment_signed without their RAA
122         /// is because their RAA serves to ACK our previous commitment_signed.
123         ///
124         /// Here's an example of how an HTLC could come to be in this state:
125         /// remote --> update_add_htlc(prev_htlc)   --> local
126         /// remote --> commitment_signed(prev_htlc) --> local
127         /// remote <-- revoke_and_ack               <-- local
128         /// remote <-- commitment_signed(prev_htlc) <-- local
129         /// [note that here, the remote does not respond with a RAA]
130         /// remote --> update_add_htlc(this_htlc)   --> local
131         /// remote --> commitment_signed(prev_htlc, this_htlc) --> local
132         /// Now `this_htlc` will be assigned this state. It's unable to be officially
133         /// accepted, i.e. included in a commitment_signed, because we're missing the
134         /// RAA that provides our next per_commitment_point. The per_commitment_point
135         /// is used to derive commitment keys, which are used to construct the
136         /// signatures in a commitment_signed message.
137         /// Implies AwaitingRemoteRevoke.
138         ///
139         /// [BOLT #2]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
140         AwaitingRemoteRevokeToAnnounce(PendingHTLCStatus),
141         /// Included in a received commitment_signed message (implying we've revoke_and_ack'd it).
142         /// We have also included this HTLC in our latest commitment_signed and are now just waiting
143         /// on the remote's revoke_and_ack to make this HTLC an irrevocable part of the state of the
144         /// channel (before it can then get forwarded and/or removed).
145         /// Implies AwaitingRemoteRevoke.
146         AwaitingAnnouncedRemoteRevoke(PendingHTLCStatus),
147         Committed,
148         /// Removed by us and a new commitment_signed was sent (if we were AwaitingRemoteRevoke when we
149         /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
150         /// we'll drop it.
151         /// Note that we have to keep an eye on the HTLC until we've received a broadcastable
152         /// commitment transaction without it as otherwise we'll have to force-close the channel to
153         /// claim it before the timeout (obviously doesn't apply to revoked HTLCs that we can't claim
154         /// anyway). That said, ChannelMonitor does this for us (see
155         /// ChannelMonitor::should_broadcast_holder_commitment_txn) so we actually remove the HTLC from
156         /// our own local state before then, once we're sure that the next commitment_signed and
157         /// ChannelMonitor::provide_latest_local_commitment_tx will not include this HTLC.
158         LocalRemoved(InboundHTLCRemovalReason),
159 }
160
161 /// Exposes the state of pending inbound HTLCs.
162 ///
163 /// At a high level, an HTLC being forwarded from one Lightning node to another Lightning node goes
164 /// through the following states in the state machine:
165 /// - Announced for addition by the originating node through the update_add_htlc message.
166 /// - Added to the commitment transaction of the receiving node and originating node in turn
167 ///   through the exchange of commitment_signed and revoke_and_ack messages.
168 /// - Announced for resolution (fulfillment or failure) by the receiving node through either one of
169 ///   the update_fulfill_htlc, update_fail_htlc, and update_fail_malformed_htlc messages.
170 /// - Removed from the commitment transaction of the originating node and receiving node in turn
171 ///   through the exchange of commitment_signed and revoke_and_ack messages.
172 ///
173 /// This can be used to inspect what next message an HTLC is waiting for to advance its state.
174 #[derive(Clone, Debug, PartialEq)]
175 pub enum InboundHTLCStateDetails {
176         /// We have added this HTLC in our commitment transaction by receiving commitment_signed and
177         /// returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
178         /// before this HTLC is included on the remote commitment transaction.
179         AwaitingRemoteRevokeToAdd,
180         /// This HTLC has been included in the commitment_signed and revoke_and_ack messages on both sides
181         /// and is included in both commitment transactions.
182         ///
183         /// This HTLC is now safe to either forward or be claimed as a payment by us. The HTLC will
184         /// remain in this state until the forwarded upstream HTLC has been resolved and we resolve this
185         /// HTLC correspondingly, or until we claim it as a payment. If it is part of a multipart
186         /// payment, it will only be claimed together with other required parts.
187         Committed,
188         /// We have received the preimage for this HTLC and it is being removed by fulfilling it with
189         /// update_fulfill_htlc. This HTLC is still on both commitment transactions, but we are awaiting
190         /// the appropriate revoke_and_ack's from the remote before this HTLC is removed from the remote
191         /// commitment transaction after update_fulfill_htlc.
192         AwaitingRemoteRevokeToRemoveFulfill,
193         /// The HTLC is being removed by failing it with update_fail_htlc or update_fail_malformed_htlc.
194         /// This HTLC is still on both commitment transactions, but we are awaiting the appropriate
195         /// revoke_and_ack's from the remote before this HTLC is removed from the remote commitment
196         /// transaction.
197         AwaitingRemoteRevokeToRemoveFail,
198 }
199
200 impl From<&InboundHTLCState> for Option<InboundHTLCStateDetails> {
201         fn from(state: &InboundHTLCState) -> Option<InboundHTLCStateDetails> {
202                 match state {
203                         InboundHTLCState::RemoteAnnounced(_) => None,
204                         InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) =>
205                                 Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToAdd),
206                         InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) =>
207                                 Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToAdd),
208                         InboundHTLCState::Committed =>
209                                 Some(InboundHTLCStateDetails::Committed),
210                         InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(_)) =>
211                                 Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail),
212                         InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed(_)) =>
213                                 Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail),
214                         InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) =>
215                                 Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFulfill),
216                 }
217         }
218 }
219
220 impl_writeable_tlv_based_enum_upgradable!(InboundHTLCStateDetails,
221         (0, AwaitingRemoteRevokeToAdd) => {},
222         (2, Committed) => {},
223         (4, AwaitingRemoteRevokeToRemoveFulfill) => {},
224         (6, AwaitingRemoteRevokeToRemoveFail) => {};
225 );
226
227 struct InboundHTLCOutput {
228         htlc_id: u64,
229         amount_msat: u64,
230         cltv_expiry: u32,
231         payment_hash: PaymentHash,
232         state: InboundHTLCState,
233 }
234
235 /// Exposes details around pending inbound HTLCs.
236 #[derive(Clone, Debug, PartialEq)]
237 pub struct InboundHTLCDetails {
238         /// The HTLC ID.
239         /// The IDs are incremented by 1 starting from 0 for each offered HTLC.
240         /// They are unique per channel and inbound/outbound direction, unless an HTLC was only announced
241         /// and not part of any commitment transaction.
242         pub htlc_id: u64,
243         /// The amount in msat.
244         pub amount_msat: u64,
245         /// The block height at which this HTLC expires.
246         pub cltv_expiry: u32,
247         /// The payment hash.
248         pub payment_hash: PaymentHash,
249         /// The state of the HTLC in the state machine.
250         ///
251         /// Determines on which commitment transactions the HTLC is included and what message the HTLC is
252         /// waiting for to advance to the next state.
253         ///
254         /// See [`InboundHTLCStateDetails`] for information on the specific states.
255         ///
256         /// LDK will always fill this field in, but when downgrading to prior versions of LDK, new
257         /// states may result in `None` here.
258         pub state: Option<InboundHTLCStateDetails>,
259         /// Whether the HTLC has an output below the local dust limit. If so, the output will be trimmed
260         /// from the local commitment transaction and added to the commitment transaction fee.
261         /// For non-anchor channels, this takes into account the cost of the second-stage HTLC
262         /// transactions as well.
263         ///
264         /// When the local commitment transaction is broadcasted as part of a unilateral closure,
265         /// the value of this HTLC will therefore not be claimable but instead burned as a transaction
266         /// fee.
267         ///
268         /// Note that dust limits are specific to each party. An HTLC can be dust for the local
269         /// commitment transaction but not for the counterparty's commitment transaction and vice versa.
270         pub is_dust: bool,
271 }
272
273 impl_writeable_tlv_based!(InboundHTLCDetails, {
274         (0, htlc_id, required),
275         (2, amount_msat, required),
276         (4, cltv_expiry, required),
277         (6, payment_hash, required),
278         (7, state, upgradable_option),
279         (8, is_dust, required),
280 });
281
282 #[cfg_attr(test, derive(Clone, Debug, PartialEq))]
283 enum OutboundHTLCState {
284         /// Added by us and included in a commitment_signed (if we were AwaitingRemoteRevoke when we
285         /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
286         /// we will promote to Committed (note that they may not accept it until the next time we
287         /// revoke, but we don't really care about that:
288         ///  * they've revoked, so worst case we can announce an old state and get our (option on)
289         ///    money back (though we won't), and,
290         ///  * we'll send them a revoke when they send a commitment_signed, and since only they're
291         ///    allowed to remove it, the "can only be removed once committed on both sides" requirement
292         ///    doesn't matter to us and it's up to them to enforce it, worst-case they jump ahead but
293         ///    we'll never get out of sync).
294         /// Note that we Box the OnionPacket as it's rather large and we don't want to blow up
295         /// OutboundHTLCOutput's size just for a temporary bit
296         LocalAnnounced(Box<msgs::OnionPacket>),
297         Committed,
298         /// Remote removed this (outbound) HTLC. We're waiting on their commitment_signed to finalize
299         /// the change (though they'll need to revoke before we fail the payment).
300         RemoteRemoved(OutboundHTLCOutcome),
301         /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
302         /// the remote side hasn't yet revoked their previous state, which we need them to do before we
303         /// can do any backwards failing. Implies AwaitingRemoteRevoke.
304         /// We also have not yet removed this HTLC in a commitment_signed message, and are waiting on a
305         /// remote revoke_and_ack on a previous state before we can do so.
306         AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome),
307         /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
308         /// the remote side hasn't yet revoked their previous state, which we need them to do before we
309         /// can do any backwards failing. Implies AwaitingRemoteRevoke.
310         /// We have removed this HTLC in our latest commitment_signed and are now just waiting on a
311         /// revoke_and_ack to drop completely.
312         AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome),
313 }
314
315 /// Exposes the state of pending outbound HTLCs.
316 ///
317 /// At a high level, an HTLC being forwarded from one Lightning node to another Lightning node goes
318 /// through the following states in the state machine:
319 /// - Announced for addition by the originating node through the update_add_htlc message.
320 /// - Added to the commitment transaction of the receiving node and originating node in turn
321 ///   through the exchange of commitment_signed and revoke_and_ack messages.
322 /// - Announced for resolution (fulfillment or failure) by the receiving node through either one of
323 ///   the update_fulfill_htlc, update_fail_htlc, and update_fail_malformed_htlc messages.
324 /// - Removed from the commitment transaction of the originating node and receiving node in turn
325 ///   through the exchange of commitment_signed and revoke_and_ack messages.
326 ///
327 /// This can be used to inspect what next message an HTLC is waiting for to advance its state.
328 #[derive(Clone, Debug, PartialEq)]
329 pub enum OutboundHTLCStateDetails {
330         /// We are awaiting the appropriate revoke_and_ack's from the remote before the HTLC is added
331         /// on the remote's commitment transaction after update_add_htlc.
332         AwaitingRemoteRevokeToAdd,
333         /// The HTLC has been added to the remote's commitment transaction by sending commitment_signed
334         /// and receiving revoke_and_ack in return.
335         ///
336         /// The HTLC will remain in this state until the remote node resolves the HTLC, or until we
337         /// unilaterally close the channel due to a timeout with an uncooperative remote node.
338         Committed,
339         /// The HTLC has been fulfilled successfully by the remote with a preimage in update_fulfill_htlc,
340         /// and we removed the HTLC from our commitment transaction by receiving commitment_signed and
341         /// returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
342         /// for the removal from its commitment transaction.
343         AwaitingRemoteRevokeToRemoveSuccess,
344         /// The HTLC has been failed by the remote with update_fail_htlc or update_fail_malformed_htlc,
345         /// and we removed the HTLC from our commitment transaction by receiving commitment_signed and
346         /// returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
347         /// for the removal from its commitment transaction.
348         AwaitingRemoteRevokeToRemoveFailure,
349 }
350
351 impl From<&OutboundHTLCState> for OutboundHTLCStateDetails {
352         fn from(state: &OutboundHTLCState) -> OutboundHTLCStateDetails {
353                 match state {
354                         OutboundHTLCState::LocalAnnounced(_) =>
355                                 OutboundHTLCStateDetails::AwaitingRemoteRevokeToAdd,
356                         OutboundHTLCState::Committed =>
357                                 OutboundHTLCStateDetails::Committed,
358                         // RemoteRemoved states are ignored as the state is transient and the remote has not committed to
359                         // the state yet.
360                         OutboundHTLCState::RemoteRemoved(_) =>
361                                 OutboundHTLCStateDetails::Committed,
362                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_)) =>
363                                 OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveSuccess,
364                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Failure(_)) =>
365                                 OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFailure,
366                         OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) =>
367                                 OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveSuccess,
368                         OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Failure(_)) =>
369                                 OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFailure,
370                 }
371         }
372 }
373
374 impl_writeable_tlv_based_enum_upgradable!(OutboundHTLCStateDetails,
375         (0, AwaitingRemoteRevokeToAdd) => {},
376         (2, Committed) => {},
377         (4, AwaitingRemoteRevokeToRemoveSuccess) => {},
378         (6, AwaitingRemoteRevokeToRemoveFailure) => {};
379 );
380
381 #[derive(Clone)]
382 #[cfg_attr(test, derive(Debug, PartialEq))]
383 enum OutboundHTLCOutcome {
384         /// LDK version 0.0.105+ will always fill in the preimage here.
385         Success(Option<PaymentPreimage>),
386         Failure(HTLCFailReason),
387 }
388
389 impl From<Option<HTLCFailReason>> for OutboundHTLCOutcome {
390         fn from(o: Option<HTLCFailReason>) -> Self {
391                 match o {
392                         None => OutboundHTLCOutcome::Success(None),
393                         Some(r) => OutboundHTLCOutcome::Failure(r)
394                 }
395         }
396 }
397
398 impl<'a> Into<Option<&'a HTLCFailReason>> for &'a OutboundHTLCOutcome {
399         fn into(self) -> Option<&'a HTLCFailReason> {
400                 match self {
401                         OutboundHTLCOutcome::Success(_) => None,
402                         OutboundHTLCOutcome::Failure(ref r) => Some(r)
403                 }
404         }
405 }
406
407 #[cfg_attr(test, derive(Clone, Debug, PartialEq))]
408 struct OutboundHTLCOutput {
409         htlc_id: u64,
410         amount_msat: u64,
411         cltv_expiry: u32,
412         payment_hash: PaymentHash,
413         state: OutboundHTLCState,
414         source: HTLCSource,
415         blinding_point: Option<PublicKey>,
416         skimmed_fee_msat: Option<u64>,
417 }
418
419 /// Exposes details around pending outbound HTLCs.
420 #[derive(Clone, Debug, PartialEq)]
421 pub struct OutboundHTLCDetails {
422         /// The HTLC ID.
423         /// The IDs are incremented by 1 starting from 0 for each offered HTLC.
424         /// They are unique per channel and inbound/outbound direction, unless an HTLC was only announced
425         /// and not part of any commitment transaction.
426         ///
427         /// Not present when we are awaiting a remote revocation and the HTLC is not added yet.
428         pub htlc_id: Option<u64>,
429         /// The amount in msat.
430         pub amount_msat: u64,
431         /// The block height at which this HTLC expires.
432         pub cltv_expiry: u32,
433         /// The payment hash.
434         pub payment_hash: PaymentHash,
435         /// The state of the HTLC in the state machine.
436         ///
437         /// Determines on which commitment transactions the HTLC is included and what message the HTLC is
438         /// waiting for to advance to the next state.
439         ///
440         /// See [`OutboundHTLCStateDetails`] for information on the specific states.
441         ///
442         /// LDK will always fill this field in, but when downgrading to prior versions of LDK, new
443         /// states may result in `None` here.
444         pub state: Option<OutboundHTLCStateDetails>,
445         /// The extra fee being skimmed off the top of this HTLC.
446         pub skimmed_fee_msat: Option<u64>,
447         /// Whether the HTLC has an output below the local dust limit. If so, the output will be trimmed
448         /// from the local commitment transaction and added to the commitment transaction fee.
449         /// For non-anchor channels, this takes into account the cost of the second-stage HTLC
450         /// transactions as well.
451         ///
452         /// When the local commitment transaction is broadcasted as part of a unilateral closure,
453         /// the value of this HTLC will therefore not be claimable but instead burned as a transaction
454         /// fee.
455         ///
456         /// Note that dust limits are specific to each party. An HTLC can be dust for the local
457         /// commitment transaction but not for the counterparty's commitment transaction and vice versa.
458         pub is_dust: bool,
459 }
460
461 impl_writeable_tlv_based!(OutboundHTLCDetails, {
462         (0, htlc_id, required),
463         (2, amount_msat, required),
464         (4, cltv_expiry, required),
465         (6, payment_hash, required),
466         (7, state, upgradable_option),
467         (8, skimmed_fee_msat, required),
468         (10, is_dust, required),
469 });
470
471 /// See AwaitingRemoteRevoke ChannelState for more info
472 #[cfg_attr(test, derive(Clone, Debug, PartialEq))]
473 enum HTLCUpdateAwaitingACK {
474         AddHTLC { // TODO: Time out if we're getting close to cltv_expiry
475                 // always outbound
476                 amount_msat: u64,
477                 cltv_expiry: u32,
478                 payment_hash: PaymentHash,
479                 source: HTLCSource,
480                 onion_routing_packet: msgs::OnionPacket,
481                 // The extra fee we're skimming off the top of this HTLC.
482                 skimmed_fee_msat: Option<u64>,
483                 blinding_point: Option<PublicKey>,
484         },
485         ClaimHTLC {
486                 payment_preimage: PaymentPreimage,
487                 htlc_id: u64,
488         },
489         FailHTLC {
490                 htlc_id: u64,
491                 err_packet: msgs::OnionErrorPacket,
492         },
493         FailMalformedHTLC {
494                 htlc_id: u64,
495                 failure_code: u16,
496                 sha256_of_onion: [u8; 32],
497         },
498 }
499
500 macro_rules! define_state_flags {
501         ($flag_type_doc: expr, $flag_type: ident, [$(($flag_doc: expr, $flag: ident, $value: expr, $get: ident, $set: ident, $clear: ident)),+], $extra_flags: expr) => {
502                 #[doc = $flag_type_doc]
503                 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq)]
504                 struct $flag_type(u32);
505
506                 impl $flag_type {
507                         $(
508                                 #[doc = $flag_doc]
509                                 const $flag: $flag_type = $flag_type($value);
510                         )*
511
512                         /// All flags that apply to the specified [`ChannelState`] variant.
513                         #[allow(unused)]
514                         const ALL: $flag_type = Self($(Self::$flag.0 | )* $extra_flags);
515
516                         #[allow(unused)]
517                         fn new() -> Self { Self(0) }
518
519                         #[allow(unused)]
520                         fn from_u32(flags: u32) -> Result<Self, ()> {
521                                 if flags & !Self::ALL.0 != 0 {
522                                         Err(())
523                                 } else {
524                                         Ok($flag_type(flags))
525                                 }
526                         }
527
528                         #[allow(unused)]
529                         fn is_empty(&self) -> bool { self.0 == 0 }
530                         #[allow(unused)]
531                         fn is_set(&self, flag: Self) -> bool { *self & flag == flag }
532                         #[allow(unused)]
533                         fn set(&mut self, flag: Self) { *self |= flag }
534                         #[allow(unused)]
535                         fn clear(&mut self, flag: Self) -> Self { self.0 &= !flag.0; *self }
536                 }
537
538                 $(
539                         define_state_flags!($flag_type, Self::$flag, $get, $set, $clear);
540                 )*
541
542                 impl core::ops::BitOr for $flag_type {
543                         type Output = Self;
544                         fn bitor(self, rhs: Self) -> Self::Output { Self(self.0 | rhs.0) }
545                 }
546                 impl core::ops::BitOrAssign for $flag_type {
547                         fn bitor_assign(&mut self, rhs: Self) { self.0 |= rhs.0; }
548                 }
549                 impl core::ops::BitAnd for $flag_type {
550                         type Output = Self;
551                         fn bitand(self, rhs: Self) -> Self::Output { Self(self.0 & rhs.0) }
552                 }
553                 impl core::ops::BitAndAssign for $flag_type {
554                         fn bitand_assign(&mut self, rhs: Self) { self.0 &= rhs.0; }
555                 }
556         };
557         ($flag_type_doc: expr, $flag_type: ident, $flags: tt) => {
558                 define_state_flags!($flag_type_doc, $flag_type, $flags, 0);
559         };
560         ($flag_type: ident, $flag: expr, $get: ident, $set: ident, $clear: ident) => {
561                 impl $flag_type {
562                         #[allow(unused)]
563                         fn $get(&self) -> bool { self.is_set($flag_type::new() | $flag) }
564                         #[allow(unused)]
565                         fn $set(&mut self) { self.set($flag_type::new() | $flag) }
566                         #[allow(unused)]
567                         fn $clear(&mut self) -> Self { self.clear($flag_type::new() | $flag) }
568                 }
569         };
570         ($flag_type_doc: expr, FUNDED_STATE, $flag_type: ident, $flags: tt) => {
571                 define_state_flags!($flag_type_doc, $flag_type, $flags, FundedStateFlags::ALL.0);
572
573                 define_state_flags!($flag_type, FundedStateFlags::PEER_DISCONNECTED,
574                         is_peer_disconnected, set_peer_disconnected, clear_peer_disconnected);
575                 define_state_flags!($flag_type, FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS,
576                         is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress);
577                 define_state_flags!($flag_type, FundedStateFlags::REMOTE_SHUTDOWN_SENT,
578                         is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent);
579                 define_state_flags!($flag_type, FundedStateFlags::LOCAL_SHUTDOWN_SENT,
580                         is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent);
581
582                 impl core::ops::BitOr<FundedStateFlags> for $flag_type {
583                         type Output = Self;
584                         fn bitor(self, rhs: FundedStateFlags) -> Self::Output { Self(self.0 | rhs.0) }
585                 }
586                 impl core::ops::BitOrAssign<FundedStateFlags> for $flag_type {
587                         fn bitor_assign(&mut self, rhs: FundedStateFlags) { self.0 |= rhs.0; }
588                 }
589                 impl core::ops::BitAnd<FundedStateFlags> for $flag_type {
590                         type Output = Self;
591                         fn bitand(self, rhs: FundedStateFlags) -> Self::Output { Self(self.0 & rhs.0) }
592                 }
593                 impl core::ops::BitAndAssign<FundedStateFlags> for $flag_type {
594                         fn bitand_assign(&mut self, rhs: FundedStateFlags) { self.0 &= rhs.0; }
595                 }
596                 impl PartialEq<FundedStateFlags> for $flag_type {
597                         fn eq(&self, other: &FundedStateFlags) -> bool { self.0 == other.0 }
598                 }
599                 impl From<FundedStateFlags> for $flag_type {
600                         fn from(flags: FundedStateFlags) -> Self { Self(flags.0) }
601                 }
602         };
603 }
604
605 /// We declare all the states/flags here together to help determine which bits are still available
606 /// to choose.
607 mod state_flags {
608         pub const OUR_INIT_SENT: u32 = 1 << 0;
609         pub const THEIR_INIT_SENT: u32 = 1 << 1;
610         pub const FUNDING_NEGOTIATED: u32 = 1 << 2;
611         pub const AWAITING_CHANNEL_READY: u32 = 1 << 3;
612         pub const THEIR_CHANNEL_READY: u32 = 1 << 4;
613         pub const OUR_CHANNEL_READY: u32 = 1 << 5;
614         pub const CHANNEL_READY: u32 = 1 << 6;
615         pub const PEER_DISCONNECTED: u32 = 1 << 7;
616         pub const MONITOR_UPDATE_IN_PROGRESS: u32 = 1 << 8;
617         pub const AWAITING_REMOTE_REVOKE: u32 = 1 << 9;
618         pub const REMOTE_SHUTDOWN_SENT: u32 = 1 << 10;
619         pub const LOCAL_SHUTDOWN_SENT: u32 = 1 << 11;
620         pub const SHUTDOWN_COMPLETE: u32 = 1 << 12;
621         pub const WAITING_FOR_BATCH: u32 = 1 << 13;
622 }
623
624 define_state_flags!(
625         "Flags that apply to all [`ChannelState`] variants in which the channel is funded.",
626         FundedStateFlags, [
627                 ("Indicates the remote side is considered \"disconnected\" and no updates are allowed \
628                         until after we've done a `channel_reestablish` dance.", PEER_DISCONNECTED, state_flags::PEER_DISCONNECTED,
629                         is_peer_disconnected, set_peer_disconnected, clear_peer_disconnected),
630                 ("Indicates the user has told us a `ChannelMonitor` update is pending async persistence \
631                         somewhere and we should pause sending any outbound messages until they've managed to \
632                         complete it.", MONITOR_UPDATE_IN_PROGRESS, state_flags::MONITOR_UPDATE_IN_PROGRESS,
633                         is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress),
634                 ("Indicates we received a `shutdown` message from the remote end. If set, they may not add \
635                         any new HTLCs to the channel, and we are expected to respond with our own `shutdown` \
636                         message when possible.", REMOTE_SHUTDOWN_SENT, state_flags::REMOTE_SHUTDOWN_SENT,
637                         is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent),
638                 ("Indicates we sent a `shutdown` message. At this point, we may not add any new HTLCs to \
639                         the channel.", LOCAL_SHUTDOWN_SENT, state_flags::LOCAL_SHUTDOWN_SENT,
640                         is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent)
641         ]
642 );
643
644 define_state_flags!(
645         "Flags that only apply to [`ChannelState::NegotiatingFunding`].",
646         NegotiatingFundingFlags, [
647                 ("Indicates we have (or are prepared to) send our `open_channel`/`accept_channel` message.",
648                         OUR_INIT_SENT, state_flags::OUR_INIT_SENT, is_our_init_sent, set_our_init_sent, clear_our_init_sent),
649                 ("Indicates we have received their `open_channel`/`accept_channel` message.",
650                         THEIR_INIT_SENT, state_flags::THEIR_INIT_SENT, is_their_init_sent, set_their_init_sent, clear_their_init_sent)
651         ]
652 );
653
654 define_state_flags!(
655         "Flags that only apply to [`ChannelState::AwaitingChannelReady`].",
656         FUNDED_STATE, AwaitingChannelReadyFlags, [
657                 ("Indicates they sent us a `channel_ready` message. Once both `THEIR_CHANNEL_READY` and \
658                         `OUR_CHANNEL_READY` are set, our state moves on to `ChannelReady`.",
659                         THEIR_CHANNEL_READY, state_flags::THEIR_CHANNEL_READY,
660                         is_their_channel_ready, set_their_channel_ready, clear_their_channel_ready),
661                 ("Indicates we sent them a `channel_ready` message. Once both `THEIR_CHANNEL_READY` and \
662                         `OUR_CHANNEL_READY` are set, our state moves on to `ChannelReady`.",
663                         OUR_CHANNEL_READY, state_flags::OUR_CHANNEL_READY,
664                         is_our_channel_ready, set_our_channel_ready, clear_our_channel_ready),
665                 ("Indicates the channel was funded in a batch and the broadcast of the funding transaction \
666                         is being held until all channels in the batch have received `funding_signed` and have \
667                         their monitors persisted.", WAITING_FOR_BATCH, state_flags::WAITING_FOR_BATCH,
668                         is_waiting_for_batch, set_waiting_for_batch, clear_waiting_for_batch)
669         ]
670 );
671
672 define_state_flags!(
673         "Flags that only apply to [`ChannelState::ChannelReady`].",
674         FUNDED_STATE, ChannelReadyFlags, [
675                 ("Indicates that we have sent a `commitment_signed` but are awaiting the responding \
676                         `revoke_and_ack` message. During this period, we can't generate new `commitment_signed` \
677                         messages as we'd be unable to determine which HTLCs they included in their `revoke_and_ack` \
678                         implicit ACK, so instead we have to hold them away temporarily to be sent later.",
679                         AWAITING_REMOTE_REVOKE, state_flags::AWAITING_REMOTE_REVOKE,
680                         is_awaiting_remote_revoke, set_awaiting_remote_revoke, clear_awaiting_remote_revoke)
681         ]
682 );
683
684 // Note that the order of this enum is implicitly defined by where each variant is placed. Take this
685 // into account when introducing new states and update `test_channel_state_order` accordingly.
686 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq)]
687 enum ChannelState {
688         /// We are negotiating the parameters required for the channel prior to funding it.
689         NegotiatingFunding(NegotiatingFundingFlags),
690         /// We have sent `funding_created` and are awaiting a `funding_signed` to advance to
691         /// `AwaitingChannelReady`. Note that this is nonsense for an inbound channel as we immediately generate
692         /// `funding_signed` upon receipt of `funding_created`, so simply skip this state.
693         FundingNegotiated,
694         /// We've received/sent `funding_created` and `funding_signed` and are thus now waiting on the
695         /// funding transaction to confirm.
696         AwaitingChannelReady(AwaitingChannelReadyFlags),
697         /// Both we and our counterparty consider the funding transaction confirmed and the channel is
698         /// now operational.
699         ChannelReady(ChannelReadyFlags),
700         /// We've successfully negotiated a `closing_signed` dance. At this point, the `ChannelManager`
701         /// is about to drop us, but we store this anyway.
702         ShutdownComplete,
703 }
704
705 macro_rules! impl_state_flag {
706         ($get: ident, $set: ident, $clear: ident, [$($state: ident),+]) => {
707                 #[allow(unused)]
708                 fn $get(&self) -> bool {
709                         match self {
710                                 $(
711                                         ChannelState::$state(flags) => flags.$get(),
712                                 )*
713                                 _ => false,
714                         }
715                 }
716                 #[allow(unused)]
717                 fn $set(&mut self) {
718                         match self {
719                                 $(
720                                         ChannelState::$state(flags) => flags.$set(),
721                                 )*
722                                 _ => debug_assert!(false, "Attempted to set flag on unexpected ChannelState"),
723                         }
724                 }
725                 #[allow(unused)]
726                 fn $clear(&mut self) {
727                         match self {
728                                 $(
729                                         ChannelState::$state(flags) => { let _ = flags.$clear(); },
730                                 )*
731                                 _ => debug_assert!(false, "Attempted to clear flag on unexpected ChannelState"),
732                         }
733                 }
734         };
735         ($get: ident, $set: ident, $clear: ident, FUNDED_STATES) => {
736                 impl_state_flag!($get, $set, $clear, [AwaitingChannelReady, ChannelReady]);
737         };
738         ($get: ident, $set: ident, $clear: ident, $state: ident) => {
739                 impl_state_flag!($get, $set, $clear, [$state]);
740         };
741 }
742
743 impl ChannelState {
744         fn from_u32(state: u32) -> Result<Self, ()> {
745                 match state {
746                         state_flags::FUNDING_NEGOTIATED => Ok(ChannelState::FundingNegotiated),
747                         state_flags::SHUTDOWN_COMPLETE => Ok(ChannelState::ShutdownComplete),
748                         val => {
749                                 if val & state_flags::AWAITING_CHANNEL_READY == state_flags::AWAITING_CHANNEL_READY {
750                                         AwaitingChannelReadyFlags::from_u32(val & !state_flags::AWAITING_CHANNEL_READY)
751                                                 .map(|flags| ChannelState::AwaitingChannelReady(flags))
752                                 } else if val & state_flags::CHANNEL_READY == state_flags::CHANNEL_READY {
753                                         ChannelReadyFlags::from_u32(val & !state_flags::CHANNEL_READY)
754                                                 .map(|flags| ChannelState::ChannelReady(flags))
755                                 } else if let Ok(flags) = NegotiatingFundingFlags::from_u32(val) {
756                                         Ok(ChannelState::NegotiatingFunding(flags))
757                                 } else {
758                                         Err(())
759                                 }
760                         },
761                 }
762         }
763
764         fn to_u32(&self) -> u32 {
765                 match self {
766                         ChannelState::NegotiatingFunding(flags) => flags.0,
767                         ChannelState::FundingNegotiated => state_flags::FUNDING_NEGOTIATED,
768                         ChannelState::AwaitingChannelReady(flags) => state_flags::AWAITING_CHANNEL_READY | flags.0,
769                         ChannelState::ChannelReady(flags) => state_flags::CHANNEL_READY | flags.0,
770                         ChannelState::ShutdownComplete => state_flags::SHUTDOWN_COMPLETE,
771                 }
772         }
773
774         fn is_pre_funded_state(&self) -> bool {
775                 matches!(self, ChannelState::NegotiatingFunding(_)|ChannelState::FundingNegotiated)
776         }
777
778         fn is_both_sides_shutdown(&self) -> bool {
779                 self.is_local_shutdown_sent() && self.is_remote_shutdown_sent()
780         }
781
782         fn with_funded_state_flags_mask(&self) -> FundedStateFlags {
783                 match self {
784                         ChannelState::AwaitingChannelReady(flags) => FundedStateFlags((*flags & FundedStateFlags::ALL).0),
785                         ChannelState::ChannelReady(flags) => FundedStateFlags((*flags & FundedStateFlags::ALL).0),
786                         _ => FundedStateFlags::new(),
787                 }
788         }
789
790         fn can_generate_new_commitment(&self) -> bool {
791                 match self {
792                         ChannelState::ChannelReady(flags) =>
793                                 !flags.is_set(ChannelReadyFlags::AWAITING_REMOTE_REVOKE) &&
794                                         !flags.is_set(FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS.into()) &&
795                                         !flags.is_set(FundedStateFlags::PEER_DISCONNECTED.into()),
796                         _ => {
797                                 debug_assert!(false, "Can only generate new commitment within ChannelReady");
798                                 false
799                         },
800                 }
801         }
802
803         impl_state_flag!(is_peer_disconnected, set_peer_disconnected, clear_peer_disconnected, FUNDED_STATES);
804         impl_state_flag!(is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress, FUNDED_STATES);
805         impl_state_flag!(is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent, FUNDED_STATES);
806         impl_state_flag!(is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent, FUNDED_STATES);
807         impl_state_flag!(is_our_channel_ready, set_our_channel_ready, clear_our_channel_ready, AwaitingChannelReady);
808         impl_state_flag!(is_their_channel_ready, set_their_channel_ready, clear_their_channel_ready, AwaitingChannelReady);
809         impl_state_flag!(is_waiting_for_batch, set_waiting_for_batch, clear_waiting_for_batch, AwaitingChannelReady);
810         impl_state_flag!(is_awaiting_remote_revoke, set_awaiting_remote_revoke, clear_awaiting_remote_revoke, ChannelReady);
811 }
812
813 pub const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
814
815 pub const DEFAULT_MAX_HTLCS: u16 = 50;
816
817 pub(crate) fn commitment_tx_base_weight(channel_type_features: &ChannelTypeFeatures) -> u64 {
818         const COMMITMENT_TX_BASE_WEIGHT: u64 = 724;
819         const COMMITMENT_TX_BASE_ANCHOR_WEIGHT: u64 = 1124;
820         if channel_type_features.supports_anchors_zero_fee_htlc_tx() { COMMITMENT_TX_BASE_ANCHOR_WEIGHT } else { COMMITMENT_TX_BASE_WEIGHT }
821 }
822
823 #[cfg(not(test))]
824 const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
825 #[cfg(test)]
826 pub const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
827
828 pub const ANCHOR_OUTPUT_VALUE_SATOSHI: u64 = 330;
829
830 /// The percentage of the channel value `holder_max_htlc_value_in_flight_msat` used to be set to,
831 /// before this was made configurable. The percentage was made configurable in LDK 0.0.107,
832 /// although LDK 0.0.104+ enabled serialization of channels with a different value set for
833 /// `holder_max_htlc_value_in_flight_msat`.
834 pub const MAX_IN_FLIGHT_PERCENT_LEGACY: u8 = 10;
835
836 /// Maximum `funding_satoshis` value according to the BOLT #2 specification, if
837 /// `option_support_large_channel` (aka wumbo channels) is not supported.
838 /// It's 2^24 - 1.
839 pub const MAX_FUNDING_SATOSHIS_NO_WUMBO: u64 = (1 << 24) - 1;
840
841 /// Total bitcoin supply in satoshis.
842 pub const TOTAL_BITCOIN_SUPPLY_SATOSHIS: u64 = 21_000_000 * 1_0000_0000;
843
844 /// The maximum network dust limit for standard script formats. This currently represents the
845 /// minimum output value for a P2SH output before Bitcoin Core 22 considers the entire
846 /// transaction non-standard and thus refuses to relay it.
847 /// We also use this as the maximum counterparty `dust_limit_satoshis` allowed, given many
848 /// implementations use this value for their dust limit today.
849 pub const MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS: u64 = 546;
850
851 /// The maximum channel dust limit we will accept from our counterparty.
852 pub const MAX_CHAN_DUST_LIMIT_SATOSHIS: u64 = MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS;
853
854 /// The dust limit is used for both the commitment transaction outputs as well as the closing
855 /// transactions. For cooperative closing transactions, we require segwit outputs, though accept
856 /// *any* segwit scripts, which are allowed to be up to 42 bytes in length.
857 /// In order to avoid having to concern ourselves with standardness during the closing process, we
858 /// simply require our counterparty to use a dust limit which will leave any segwit output
859 /// standard.
860 /// See <https://github.com/lightning/bolts/issues/905> for more details.
861 pub const MIN_CHAN_DUST_LIMIT_SATOSHIS: u64 = 354;
862
863 // Just a reasonable implementation-specific safe lower bound, higher than the dust limit.
864 pub const MIN_THEIR_CHAN_RESERVE_SATOSHIS: u64 = 1000;
865
866 /// Used to return a simple Error back to ChannelManager. Will get converted to a
867 /// msgs::ErrorAction::SendErrorMessage or msgs::ErrorAction::IgnoreError as appropriate with our
868 /// channel_id in ChannelManager.
869 pub(super) enum ChannelError {
870         Ignore(String),
871         Warn(String),
872         Close(String),
873 }
874
875 impl fmt::Debug for ChannelError {
876         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
877                 match self {
878                         &ChannelError::Ignore(ref e) => write!(f, "Ignore : {}", e),
879                         &ChannelError::Warn(ref e) => write!(f, "Warn : {}", e),
880                         &ChannelError::Close(ref e) => write!(f, "Close : {}", e),
881                 }
882         }
883 }
884
885 impl fmt::Display for ChannelError {
886         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
887                 match self {
888                         &ChannelError::Ignore(ref e) => write!(f, "{}", e),
889                         &ChannelError::Warn(ref e) => write!(f, "{}", e),
890                         &ChannelError::Close(ref e) => write!(f, "{}", e),
891                 }
892         }
893 }
894
895 pub(super) struct WithChannelContext<'a, L: Deref> where L::Target: Logger {
896         pub logger: &'a L,
897         pub peer_id: Option<PublicKey>,
898         pub channel_id: Option<ChannelId>,
899 }
900
901 impl<'a, L: Deref> Logger for WithChannelContext<'a, L> where L::Target: Logger {
902         fn log(&self, mut record: Record) {
903                 record.peer_id = self.peer_id;
904                 record.channel_id = self.channel_id;
905                 self.logger.log(record)
906         }
907 }
908
909 impl<'a, 'b, L: Deref> WithChannelContext<'a, L>
910 where L::Target: Logger {
911         pub(super) fn from<S: Deref>(logger: &'a L, context: &'b ChannelContext<S>) -> Self
912         where S::Target: SignerProvider
913         {
914                 WithChannelContext {
915                         logger,
916                         peer_id: Some(context.counterparty_node_id),
917                         channel_id: Some(context.channel_id),
918                 }
919         }
920 }
921
922 macro_rules! secp_check {
923         ($res: expr, $err: expr) => {
924                 match $res {
925                         Ok(thing) => thing,
926                         Err(_) => return Err(ChannelError::Close($err)),
927                 }
928         };
929 }
930
931 /// The "channel disabled" bit in channel_update must be set based on whether we are connected to
932 /// our counterparty or not. However, we don't want to announce updates right away to avoid
933 /// spamming the network with updates if the connection is flapping. Instead, we "stage" updates to
934 /// our channel_update message and track the current state here.
935 /// See implementation at [`super::channelmanager::ChannelManager::timer_tick_occurred`].
936 #[derive(Clone, Copy, PartialEq)]
937 pub(super) enum ChannelUpdateStatus {
938         /// We've announced the channel as enabled and are connected to our peer.
939         Enabled,
940         /// Our channel is no longer live, but we haven't announced the channel as disabled yet.
941         DisabledStaged(u8),
942         /// Our channel is live again, but we haven't announced the channel as enabled yet.
943         EnabledStaged(u8),
944         /// We've announced the channel as disabled.
945         Disabled,
946 }
947
948 /// We track when we sent an `AnnouncementSignatures` to our peer in a few states, described here.
949 #[derive(PartialEq)]
950 pub enum AnnouncementSigsState {
951         /// We have not sent our peer an `AnnouncementSignatures` yet, or our peer disconnected since
952         /// we sent the last `AnnouncementSignatures`.
953         NotSent,
954         /// We sent an `AnnouncementSignatures` to our peer since the last time our peer disconnected.
955         /// This state never appears on disk - instead we write `NotSent`.
956         MessageSent,
957         /// We sent a `CommitmentSigned` after the last `AnnouncementSignatures` we sent. Because we
958         /// only ever have a single `CommitmentSigned` pending at once, if we sent one after sending
959         /// `AnnouncementSignatures` then we know the peer received our `AnnouncementSignatures` if
960         /// they send back a `RevokeAndACK`.
961         /// This state never appears on disk - instead we write `NotSent`.
962         Committed,
963         /// We received a `RevokeAndACK`, effectively ack-ing our `AnnouncementSignatures`, at this
964         /// point we no longer need to re-send our `AnnouncementSignatures` again on reconnect.
965         PeerReceived,
966 }
967
968 /// An enum indicating whether the local or remote side offered a given HTLC.
969 enum HTLCInitiator {
970         LocalOffered,
971         RemoteOffered,
972 }
973
974 /// An enum gathering stats on pending HTLCs, either inbound or outbound side.
975 struct HTLCStats {
976         pending_htlcs: u32,
977         pending_htlcs_value_msat: u64,
978         on_counterparty_tx_dust_exposure_msat: u64,
979         on_holder_tx_dust_exposure_msat: u64,
980         holding_cell_msat: u64,
981         on_holder_tx_holding_cell_htlcs_count: u32, // dust HTLCs *non*-included
982 }
983
984 /// An enum gathering stats on commitment transaction, either local or remote.
985 struct CommitmentStats<'a> {
986         tx: CommitmentTransaction, // the transaction info
987         feerate_per_kw: u32, // the feerate included to build the transaction
988         total_fee_sat: u64, // the total fee included in the transaction
989         num_nondust_htlcs: usize,  // the number of HTLC outputs (dust HTLCs *non*-included)
990         htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, // the list of HTLCs (dust HTLCs *included*) which were not ignored when building the transaction
991         local_balance_msat: u64, // local balance before fees *not* considering dust limits
992         remote_balance_msat: u64, // remote balance before fees *not* considering dust limits
993         outbound_htlc_preimages: Vec<PaymentPreimage>, // preimages for successful offered HTLCs since last commitment
994         inbound_htlc_preimages: Vec<PaymentPreimage>, // preimages for successful received HTLCs since last commitment
995 }
996
997 /// Used when calculating whether we or the remote can afford an additional HTLC.
998 struct HTLCCandidate {
999         amount_msat: u64,
1000         origin: HTLCInitiator,
1001 }
1002
1003 impl HTLCCandidate {
1004         fn new(amount_msat: u64, origin: HTLCInitiator) -> Self {
1005                 Self {
1006                         amount_msat,
1007                         origin,
1008                 }
1009         }
1010 }
1011
1012 /// A return value enum for get_update_fulfill_htlc. See UpdateFulfillCommitFetch variants for
1013 /// description
1014 enum UpdateFulfillFetch {
1015         NewClaim {
1016                 monitor_update: ChannelMonitorUpdate,
1017                 htlc_value_msat: u64,
1018                 msg: Option<msgs::UpdateFulfillHTLC>,
1019         },
1020         DuplicateClaim {},
1021 }
1022
1023 /// The return type of get_update_fulfill_htlc_and_commit.
1024 pub enum UpdateFulfillCommitFetch {
1025         /// Indicates the HTLC fulfill is new, and either generated an update_fulfill message, placed
1026         /// it in the holding cell, or re-generated the update_fulfill message after the same claim was
1027         /// previously placed in the holding cell (and has since been removed).
1028         NewClaim {
1029                 /// The ChannelMonitorUpdate which places the new payment preimage in the channel monitor
1030                 monitor_update: ChannelMonitorUpdate,
1031                 /// The value of the HTLC which was claimed, in msat.
1032                 htlc_value_msat: u64,
1033         },
1034         /// Indicates the HTLC fulfill is duplicative and already existed either in the holding cell
1035         /// or has been forgotten (presumably previously claimed).
1036         DuplicateClaim {},
1037 }
1038
1039 /// The return value of `monitor_updating_restored`
1040 pub(super) struct MonitorRestoreUpdates {
1041         pub raa: Option<msgs::RevokeAndACK>,
1042         pub commitment_update: Option<msgs::CommitmentUpdate>,
1043         pub order: RAACommitmentOrder,
1044         pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
1045         pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
1046         pub finalized_claimed_htlcs: Vec<HTLCSource>,
1047         pub funding_broadcastable: Option<Transaction>,
1048         pub channel_ready: Option<msgs::ChannelReady>,
1049         pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
1050 }
1051
1052 /// The return value of `signer_maybe_unblocked`
1053 #[allow(unused)]
1054 pub(super) struct SignerResumeUpdates {
1055         pub commitment_update: Option<msgs::CommitmentUpdate>,
1056         pub funding_signed: Option<msgs::FundingSigned>,
1057         pub channel_ready: Option<msgs::ChannelReady>,
1058 }
1059
1060 /// The return value of `channel_reestablish`
1061 pub(super) struct ReestablishResponses {
1062         pub channel_ready: Option<msgs::ChannelReady>,
1063         pub raa: Option<msgs::RevokeAndACK>,
1064         pub commitment_update: Option<msgs::CommitmentUpdate>,
1065         pub order: RAACommitmentOrder,
1066         pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
1067         pub shutdown_msg: Option<msgs::Shutdown>,
1068 }
1069
1070 /// The result of a shutdown that should be handled.
1071 #[must_use]
1072 pub(crate) struct ShutdownResult {
1073         pub(crate) closure_reason: ClosureReason,
1074         /// A channel monitor update to apply.
1075         pub(crate) monitor_update: Option<(PublicKey, OutPoint, ChannelId, ChannelMonitorUpdate)>,
1076         /// A list of dropped outbound HTLCs that can safely be failed backwards immediately.
1077         pub(crate) dropped_outbound_htlcs: Vec<(HTLCSource, PaymentHash, PublicKey, ChannelId)>,
1078         /// An unbroadcasted batch funding transaction id. The closure of this channel should be
1079         /// propagated to the remainder of the batch.
1080         pub(crate) unbroadcasted_batch_funding_txid: Option<Txid>,
1081         pub(crate) channel_id: ChannelId,
1082         pub(crate) user_channel_id: u128,
1083         pub(crate) channel_capacity_satoshis: u64,
1084         pub(crate) counterparty_node_id: PublicKey,
1085         pub(crate) unbroadcasted_funding_tx: Option<Transaction>,
1086         pub(crate) channel_funding_txo: Option<OutPoint>,
1087 }
1088
1089 /// If the majority of the channels funds are to the fundee and the initiator holds only just
1090 /// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
1091 /// initiator controls the feerate, if they then go to increase the channel fee, they may have no
1092 /// balance but the fundee is unable to send a payment as the increase in fee more than drains
1093 /// their reserve value. Thus, neither side can send a new HTLC and the channel becomes useless.
1094 /// Thus, before sending an HTLC when we are the initiator, we check that the feerate can increase
1095 /// by this multiple without hitting this case, before sending.
1096 /// This multiple is effectively the maximum feerate "jump" we expect until more HTLCs flow over
1097 /// the channel. Sadly, there isn't really a good number for this - if we expect to have no new
1098 /// HTLCs for days we may need this to suffice for feerate increases across days, but that may
1099 /// leave the channel less usable as we hold a bigger reserve.
1100 #[cfg(any(fuzzing, test))]
1101 pub const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
1102 #[cfg(not(any(fuzzing, test)))]
1103 const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
1104
1105 /// If we fail to see a funding transaction confirmed on-chain within this many blocks after the
1106 /// channel creation on an inbound channel, we simply force-close and move on.
1107 /// This constant is the one suggested in BOLT 2.
1108 pub(crate) const FUNDING_CONF_DEADLINE_BLOCKS: u32 = 2016;
1109
1110 /// In case of a concurrent update_add_htlc proposed by our counterparty, we might
1111 /// not have enough balance value remaining to cover the onchain cost of this new
1112 /// HTLC weight. If this happens, our counterparty fails the reception of our
1113 /// commitment_signed including this new HTLC due to infringement on the channel
1114 /// reserve.
1115 /// To prevent this case, we compute our outbound update_fee with an HTLC buffer of
1116 /// size 2. However, if the number of concurrent update_add_htlc is higher, this still
1117 /// leads to a channel force-close. Ultimately, this is an issue coming from the
1118 /// design of LN state machines, allowing asynchronous updates.
1119 pub(crate) const CONCURRENT_INBOUND_HTLC_FEE_BUFFER: u32 = 2;
1120
1121 /// When a channel is opened, we check that the funding amount is enough to pay for relevant
1122 /// commitment transaction fees, with at least this many HTLCs present on the commitment
1123 /// transaction (not counting the value of the HTLCs themselves).
1124 pub(crate) const MIN_AFFORDABLE_HTLC_COUNT: usize = 4;
1125
1126 /// When a [`Channel`] has its [`ChannelConfig`] updated, its existing one is stashed for up to this
1127 /// number of ticks to allow forwarding HTLCs by nodes that have yet to receive the new
1128 /// ChannelUpdate prompted by the config update. This value was determined as follows:
1129 ///
1130 ///   * The expected interval between ticks (1 minute).
1131 ///   * The average convergence delay of updates across the network, i.e., ~300 seconds on average
1132 ///      for a node to see an update as seen on `<https://arxiv.org/pdf/2205.12737.pdf>`.
1133 ///   * `EXPIRE_PREV_CONFIG_TICKS` = convergence_delay / tick_interval
1134 pub(crate) const EXPIRE_PREV_CONFIG_TICKS: usize = 5;
1135
1136 /// The number of ticks that may elapse while we're waiting for a response to a
1137 /// [`msgs::RevokeAndACK`] or [`msgs::ChannelReestablish`] message before we attempt to disconnect
1138 /// them.
1139 ///
1140 /// See [`ChannelContext::sent_message_awaiting_response`] for more information.
1141 pub(crate) const DISCONNECT_PEER_AWAITING_RESPONSE_TICKS: usize = 2;
1142
1143 /// The number of ticks that may elapse while we're waiting for an unfunded outbound/inbound channel
1144 /// to be promoted to a [`Channel`] since the unfunded channel was created. An unfunded channel
1145 /// exceeding this age limit will be force-closed and purged from memory.
1146 pub(crate) const UNFUNDED_CHANNEL_AGE_LIMIT_TICKS: usize = 60;
1147
1148 /// Number of blocks needed for an output from a coinbase transaction to be spendable.
1149 pub(crate) const COINBASE_MATURITY: u32 = 100;
1150
1151 struct PendingChannelMonitorUpdate {
1152         update: ChannelMonitorUpdate,
1153 }
1154
1155 impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
1156         (0, update, required),
1157 });
1158
1159 /// The `ChannelPhase` enum describes the current phase in life of a lightning channel with each of
1160 /// its variants containing an appropriate channel struct.
1161 pub(super) enum ChannelPhase<SP: Deref> where SP::Target: SignerProvider {
1162         UnfundedOutboundV1(OutboundV1Channel<SP>),
1163         UnfundedInboundV1(InboundV1Channel<SP>),
1164         Funded(Channel<SP>),
1165 }
1166
1167 impl<'a, SP: Deref> ChannelPhase<SP> where
1168         SP::Target: SignerProvider,
1169         <SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
1170 {
1171         pub fn context(&'a self) -> &'a ChannelContext<SP> {
1172                 match self {
1173                         ChannelPhase::Funded(chan) => &chan.context,
1174                         ChannelPhase::UnfundedOutboundV1(chan) => &chan.context,
1175                         ChannelPhase::UnfundedInboundV1(chan) => &chan.context,
1176                 }
1177         }
1178
1179         pub fn context_mut(&'a mut self) -> &'a mut ChannelContext<SP> {
1180                 match self {
1181                         ChannelPhase::Funded(ref mut chan) => &mut chan.context,
1182                         ChannelPhase::UnfundedOutboundV1(ref mut chan) => &mut chan.context,
1183                         ChannelPhase::UnfundedInboundV1(ref mut chan) => &mut chan.context,
1184                 }
1185         }
1186 }
1187
1188 /// Contains all state common to unfunded inbound/outbound channels.
1189 pub(super) struct UnfundedChannelContext {
1190         /// A counter tracking how many ticks have elapsed since this unfunded channel was
1191         /// created. If this unfunded channel reaches peer has yet to respond after reaching
1192         /// `UNFUNDED_CHANNEL_AGE_LIMIT_TICKS`, it will be force-closed and purged from memory.
1193         ///
1194         /// This is so that we don't keep channels around that haven't progressed to a funded state
1195         /// in a timely manner.
1196         unfunded_channel_age_ticks: usize,
1197 }
1198
1199 impl UnfundedChannelContext {
1200         /// Determines whether we should force-close and purge this unfunded channel from memory due to it
1201         /// having reached the unfunded channel age limit.
1202         ///
1203         /// This should be called on every [`super::channelmanager::ChannelManager::timer_tick_occurred`].
1204         pub fn should_expire_unfunded_channel(&mut self) -> bool {
1205                 self.unfunded_channel_age_ticks += 1;
1206                 self.unfunded_channel_age_ticks >= UNFUNDED_CHANNEL_AGE_LIMIT_TICKS
1207         }
1208 }
1209
1210 /// Contains everything about the channel including state, and various flags.
1211 pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
1212         config: LegacyChannelConfig,
1213
1214         // Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
1215         // constructed using it. The second element in the tuple corresponds to the number of ticks that
1216         // have elapsed since the update occurred.
1217         prev_config: Option<(ChannelConfig, usize)>,
1218
1219         inbound_handshake_limits_override: Option<ChannelHandshakeLimits>,
1220
1221         user_id: u128,
1222
1223         /// The current channel ID.
1224         channel_id: ChannelId,
1225         /// The temporary channel ID used during channel setup. Value kept even after transitioning to a final channel ID.
1226         /// Will be `None` for channels created prior to 0.0.115.
1227         temporary_channel_id: Option<ChannelId>,
1228         channel_state: ChannelState,
1229
1230         // When we reach max(6 blocks, minimum_depth), we need to send an AnnouncementSigs message to
1231         // our peer. However, we want to make sure they received it, or else rebroadcast it when we
1232         // next connect.
1233         // We do so here, see `AnnouncementSigsSent` for more details on the state(s).
1234         // Note that a number of our tests were written prior to the behavior here which retransmits
1235         // AnnouncementSignatures until after an RAA completes, so the behavior is short-circuited in
1236         // many tests.
1237         #[cfg(any(test, feature = "_test_utils"))]
1238         pub(crate) announcement_sigs_state: AnnouncementSigsState,
1239         #[cfg(not(any(test, feature = "_test_utils")))]
1240         announcement_sigs_state: AnnouncementSigsState,
1241
1242         secp_ctx: Secp256k1<secp256k1::All>,
1243         channel_value_satoshis: u64,
1244
1245         latest_monitor_update_id: u64,
1246
1247         holder_signer: ChannelSignerType<SP>,
1248         shutdown_scriptpubkey: Option<ShutdownScript>,
1249         destination_script: ScriptBuf,
1250
1251         // Our commitment numbers start at 2^48-1 and count down, whereas the ones used in transaction
1252         // generation start at 0 and count up...this simplifies some parts of implementation at the
1253         // cost of others, but should really just be changed.
1254
1255         cur_holder_commitment_transaction_number: u64,
1256         cur_counterparty_commitment_transaction_number: u64,
1257         value_to_self_msat: u64, // Excluding all pending_htlcs, fees, and anchor outputs
1258         pending_inbound_htlcs: Vec<InboundHTLCOutput>,
1259         pending_outbound_htlcs: Vec<OutboundHTLCOutput>,
1260         holding_cell_htlc_updates: Vec<HTLCUpdateAwaitingACK>,
1261
1262         /// When resending CS/RAA messages on channel monitor restoration or on reconnect, we always
1263         /// need to ensure we resend them in the order we originally generated them. Note that because
1264         /// there can only ever be one in-flight CS and/or one in-flight RAA at any time, it is
1265         /// sufficient to simply set this to the opposite of any message we are generating as we
1266         /// generate it. ie when we generate a CS, we set this to RAAFirst as, if there is a pending
1267         /// in-flight RAA to resend, it will have been the first thing we generated, and thus we should
1268         /// send it first.
1269         resend_order: RAACommitmentOrder,
1270
1271         monitor_pending_channel_ready: bool,
1272         monitor_pending_revoke_and_ack: bool,
1273         monitor_pending_commitment_signed: bool,
1274
1275         // TODO: If a channel is drop'd, we don't know whether the `ChannelMonitor` is ultimately
1276         // responsible for some of the HTLCs here or not - we don't know whether the update in question
1277         // completed or not. We currently ignore these fields entirely when force-closing a channel,
1278         // but need to handle this somehow or we run the risk of losing HTLCs!
1279         monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
1280         monitor_pending_failures: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
1281         monitor_pending_finalized_fulfills: Vec<HTLCSource>,
1282
1283         /// If we went to send a commitment update (ie some messages then [`msgs::CommitmentSigned`])
1284         /// but our signer (initially) refused to give us a signature, we should retry at some point in
1285         /// the future when the signer indicates it may have a signature for us.
1286         ///
1287         /// This flag is set in such a case. Note that we don't need to persist this as we'll end up
1288         /// setting it again as a side-effect of [`Channel::channel_reestablish`].
1289         signer_pending_commitment_update: bool,
1290         /// Similar to [`Self::signer_pending_commitment_update`] but we're waiting to send either a
1291         /// [`msgs::FundingCreated`] or [`msgs::FundingSigned`] depending on if this channel is
1292         /// outbound or inbound.
1293         signer_pending_funding: bool,
1294
1295         // pending_update_fee is filled when sending and receiving update_fee.
1296         //
1297         // Because it follows the same commitment flow as HTLCs, `FeeUpdateState` is either `Outbound`
1298         // or matches a subset of the `InboundHTLCOutput` variants. It is then updated/used when
1299         // generating new commitment transactions with exactly the same criteria as inbound/outbound
1300         // HTLCs with similar state.
1301         pending_update_fee: Option<(u32, FeeUpdateState)>,
1302         // If a `send_update_fee()` call is made with ChannelState::AwaitingRemoteRevoke set, we place
1303         // it here instead of `pending_update_fee` in the same way as we place outbound HTLC updates in
1304         // `holding_cell_htlc_updates` instead of `pending_outbound_htlcs`. It is released into
1305         // `pending_update_fee` with the same criteria as outbound HTLC updates but can be updated by
1306         // further `send_update_fee` calls, dropping the previous holding cell update entirely.
1307         holding_cell_update_fee: Option<u32>,
1308         next_holder_htlc_id: u64,
1309         next_counterparty_htlc_id: u64,
1310         feerate_per_kw: u32,
1311
1312         /// The timestamp set on our latest `channel_update` message for this channel. It is updated
1313         /// when the channel is updated in ways which may impact the `channel_update` message or when a
1314         /// new block is received, ensuring it's always at least moderately close to the current real
1315         /// time.
1316         update_time_counter: u32,
1317
1318         #[cfg(debug_assertions)]
1319         /// Max to_local and to_remote outputs in a locally-generated commitment transaction
1320         holder_max_commitment_tx_output: Mutex<(u64, u64)>,
1321         #[cfg(debug_assertions)]
1322         /// Max to_local and to_remote outputs in a remote-generated commitment transaction
1323         counterparty_max_commitment_tx_output: Mutex<(u64, u64)>,
1324
1325         last_sent_closing_fee: Option<(u64, Signature)>, // (fee, holder_sig)
1326         target_closing_feerate_sats_per_kw: Option<u32>,
1327
1328         /// If our counterparty sent us a closing_signed while we were waiting for a `ChannelMonitor`
1329         /// update, we need to delay processing it until later. We do that here by simply storing the
1330         /// closing_signed message and handling it in `maybe_propose_closing_signed`.
1331         pending_counterparty_closing_signed: Option<msgs::ClosingSigned>,
1332
1333         /// The minimum and maximum absolute fee, in satoshis, we are willing to place on the closing
1334         /// transaction. These are set once we reach `closing_negotiation_ready`.
1335         #[cfg(test)]
1336         pub(crate) closing_fee_limits: Option<(u64, u64)>,
1337         #[cfg(not(test))]
1338         closing_fee_limits: Option<(u64, u64)>,
1339
1340         /// If we remove an HTLC (or fee update), commit, and receive our counterparty's
1341         /// `revoke_and_ack`, we remove all knowledge of said HTLC (or fee update). However, the latest
1342         /// local commitment transaction that we can broadcast still contains the HTLC (or old fee)
1343         /// until we receive a further `commitment_signed`. Thus we are not eligible for initiating the
1344         /// `closing_signed` negotiation if we're expecting a counterparty `commitment_signed`.
1345         ///
1346         /// To ensure we don't send a `closing_signed` too early, we track this state here, waiting
1347         /// until we see a `commitment_signed` before doing so.
1348         ///
1349         /// We don't bother to persist this - we anticipate this state won't last longer than a few
1350         /// milliseconds, so any accidental force-closes here should be exceedingly rare.
1351         expecting_peer_commitment_signed: bool,
1352
1353         /// The hash of the block in which the funding transaction was included.
1354         funding_tx_confirmed_in: Option<BlockHash>,
1355         funding_tx_confirmation_height: u32,
1356         short_channel_id: Option<u64>,
1357         /// Either the height at which this channel was created or the height at which it was last
1358         /// serialized if it was serialized by versions prior to 0.0.103.
1359         /// We use this to close if funding is never broadcasted.
1360         channel_creation_height: u32,
1361
1362         counterparty_dust_limit_satoshis: u64,
1363
1364         #[cfg(test)]
1365         pub(super) holder_dust_limit_satoshis: u64,
1366         #[cfg(not(test))]
1367         holder_dust_limit_satoshis: u64,
1368
1369         #[cfg(test)]
1370         pub(super) counterparty_max_htlc_value_in_flight_msat: u64,
1371         #[cfg(not(test))]
1372         counterparty_max_htlc_value_in_flight_msat: u64,
1373
1374         #[cfg(test)]
1375         pub(super) holder_max_htlc_value_in_flight_msat: u64,
1376         #[cfg(not(test))]
1377         holder_max_htlc_value_in_flight_msat: u64,
1378
1379         /// minimum channel reserve for self to maintain - set by them.
1380         counterparty_selected_channel_reserve_satoshis: Option<u64>,
1381
1382         #[cfg(test)]
1383         pub(super) holder_selected_channel_reserve_satoshis: u64,
1384         #[cfg(not(test))]
1385         holder_selected_channel_reserve_satoshis: u64,
1386
1387         counterparty_htlc_minimum_msat: u64,
1388         holder_htlc_minimum_msat: u64,
1389         #[cfg(test)]
1390         pub counterparty_max_accepted_htlcs: u16,
1391         #[cfg(not(test))]
1392         counterparty_max_accepted_htlcs: u16,
1393         holder_max_accepted_htlcs: u16,
1394         minimum_depth: Option<u32>,
1395
1396         counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,
1397
1398         pub(crate) channel_transaction_parameters: ChannelTransactionParameters,
1399         funding_transaction: Option<Transaction>,
1400         is_batch_funding: Option<()>,
1401
1402         counterparty_cur_commitment_point: Option<PublicKey>,
1403         counterparty_prev_commitment_point: Option<PublicKey>,
1404         counterparty_node_id: PublicKey,
1405
1406         counterparty_shutdown_scriptpubkey: Option<ScriptBuf>,
1407
1408         commitment_secrets: CounterpartyCommitmentSecrets,
1409
1410         channel_update_status: ChannelUpdateStatus,
1411         /// Once we reach `closing_negotiation_ready`, we set this, indicating if closing_signed does
1412         /// not complete within a single timer tick (one minute), we should force-close the channel.
1413         /// This prevents us from keeping unusable channels around forever if our counterparty wishes
1414         /// to DoS us.
1415         /// Note that this field is reset to false on deserialization to give us a chance to connect to
1416         /// our peer and start the closing_signed negotiation fresh.
1417         closing_signed_in_flight: bool,
1418
1419         /// Our counterparty's channel_announcement signatures provided in announcement_signatures.
1420         /// This can be used to rebroadcast the channel_announcement message later.
1421         announcement_sigs: Option<(Signature, Signature)>,
1422
1423         // We save these values so we can make sure `next_local_commit_tx_fee_msat` and
1424         // `next_remote_commit_tx_fee_msat` properly predict what the next commitment transaction fee will
1425         // be, by comparing the cached values to the fee of the tranaction generated by
1426         // `build_commitment_transaction`.
1427         #[cfg(any(test, fuzzing))]
1428         next_local_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
1429         #[cfg(any(test, fuzzing))]
1430         next_remote_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
1431
1432         /// lnd has a long-standing bug where, upon reconnection, if the channel is not yet confirmed
1433         /// they will not send a channel_reestablish until the channel locks in. Then, they will send a
1434         /// channel_ready *before* sending the channel_reestablish (which is clearly a violation of
1435         /// the BOLT specs). We copy c-lightning's workaround here and simply store the channel_ready
1436         /// message until we receive a channel_reestablish.
1437         ///
1438         /// See-also <https://github.com/lightningnetwork/lnd/issues/4006>
1439         pub workaround_lnd_bug_4006: Option<msgs::ChannelReady>,
1440
1441         /// An option set when we wish to track how many ticks have elapsed while waiting for a response
1442         /// from our counterparty after sending a message. If the peer has yet to respond after reaching
1443         /// `DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`, a reconnection should be attempted to try to
1444         /// unblock the state machine.
1445         ///
1446         /// This behavior is mostly motivated by a lnd bug in which we don't receive a message we expect
1447         /// to in a timely manner, which may lead to channels becoming unusable and/or force-closed. An
1448         /// example of such can be found at <https://github.com/lightningnetwork/lnd/issues/7682>.
1449         ///
1450         /// This is currently only used when waiting for a [`msgs::ChannelReestablish`] or
1451         /// [`msgs::RevokeAndACK`] message from the counterparty.
1452         sent_message_awaiting_response: Option<usize>,
1453
1454         #[cfg(any(test, fuzzing))]
1455         // When we receive an HTLC fulfill on an outbound path, we may immediately fulfill the
1456         // corresponding HTLC on the inbound path. If, then, the outbound path channel is
1457         // disconnected and reconnected (before we've exchange commitment_signed and revoke_and_ack
1458         // messages), they may re-broadcast their update_fulfill_htlc, causing a duplicate claim. This
1459         // is fine, but as a sanity check in our failure to generate the second claim, we check here
1460         // that the original was a claim, and that we aren't now trying to fulfill a failed HTLC.
1461         historical_inbound_htlc_fulfills: HashSet<u64>,
1462
1463         /// This channel's type, as negotiated during channel open
1464         channel_type: ChannelTypeFeatures,
1465
1466         // Our counterparty can offer us SCID aliases which they will map to this channel when routing
1467         // outbound payments. These can be used in invoice route hints to avoid explicitly revealing
1468         // the channel's funding UTXO.
1469         //
1470         // We also use this when sending our peer a channel_update that isn't to be broadcasted
1471         // publicly - allowing them to re-use their map of SCID -> channel for channel_update ->
1472         // associated channel mapping.
1473         //
1474         // We only bother storing the most recent SCID alias at any time, though our counterparty has
1475         // to store all of them.
1476         latest_inbound_scid_alias: Option<u64>,
1477
1478         // We always offer our counterparty a static SCID alias, which we recognize as for this channel
1479         // if we see it in HTLC forwarding instructions. We don't bother rotating the alias given we
1480         // don't currently support node id aliases and eventually privacy should be provided with
1481         // blinded paths instead of simple scid+node_id aliases.
1482         outbound_scid_alias: u64,
1483
1484         // We track whether we already emitted a `ChannelPending` event.
1485         channel_pending_event_emitted: bool,
1486
1487         // We track whether we already emitted a `ChannelReady` event.
1488         channel_ready_event_emitted: bool,
1489
1490         /// Some if we initiated to shut down the channel.
1491         local_initiated_shutdown: Option<()>,
1492
1493         /// The unique identifier used to re-derive the private key material for the channel through
1494         /// [`SignerProvider::derive_channel_signer`].
1495         channel_keys_id: [u8; 32],
1496
1497         /// If we can't release a [`ChannelMonitorUpdate`] until some external action completes, we
1498         /// store it here and only release it to the `ChannelManager` once it asks for it.
1499         blocked_monitor_updates: Vec<PendingChannelMonitorUpdate>,
1500 }
1501
1502 impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
1503         /// Allowed in any state (including after shutdown)
1504         pub fn get_update_time_counter(&self) -> u32 {
1505                 self.update_time_counter
1506         }
1507
1508         pub fn get_latest_monitor_update_id(&self) -> u64 {
1509                 self.latest_monitor_update_id
1510         }
1511
1512         pub fn should_announce(&self) -> bool {
1513                 self.config.announced_channel
1514         }
1515
1516         pub fn is_outbound(&self) -> bool {
1517                 self.channel_transaction_parameters.is_outbound_from_holder
1518         }
1519
1520         /// Gets the fee we'd want to charge for adding an HTLC output to this Channel
1521         /// Allowed in any state (including after shutdown)
1522         pub fn get_outbound_forwarding_fee_base_msat(&self) -> u32 {
1523                 self.config.options.forwarding_fee_base_msat
1524         }
1525
1526         /// Returns true if we've ever received a message from the remote end for this Channel
1527         pub fn have_received_message(&self) -> bool {
1528                 self.channel_state > ChannelState::NegotiatingFunding(NegotiatingFundingFlags::OUR_INIT_SENT)
1529         }
1530
1531         /// Returns true if this channel is fully established and not known to be closing.
1532         /// Allowed in any state (including after shutdown)
1533         pub fn is_usable(&self) -> bool {
1534                 matches!(self.channel_state, ChannelState::ChannelReady(_)) &&
1535                         !self.channel_state.is_local_shutdown_sent() &&
1536                         !self.channel_state.is_remote_shutdown_sent() &&
1537                         !self.monitor_pending_channel_ready
1538         }
1539
1540         /// shutdown state returns the state of the channel in its various stages of shutdown
1541         pub fn shutdown_state(&self) -> ChannelShutdownState {
1542                 match self.channel_state {
1543                         ChannelState::AwaitingChannelReady(_)|ChannelState::ChannelReady(_) =>
1544                                 if self.channel_state.is_local_shutdown_sent() && !self.channel_state.is_remote_shutdown_sent() {
1545                                         ChannelShutdownState::ShutdownInitiated
1546                                 } else if (self.channel_state.is_local_shutdown_sent() || self.channel_state.is_remote_shutdown_sent()) && !self.closing_negotiation_ready() {
1547                                         ChannelShutdownState::ResolvingHTLCs
1548                                 } else if (self.channel_state.is_local_shutdown_sent() || self.channel_state.is_remote_shutdown_sent()) && self.closing_negotiation_ready() {
1549                                         ChannelShutdownState::NegotiatingClosingFee
1550                                 } else {
1551                                         ChannelShutdownState::NotShuttingDown
1552                                 },
1553                         ChannelState::ShutdownComplete => ChannelShutdownState::ShutdownComplete,
1554                         _ => ChannelShutdownState::NotShuttingDown,
1555                 }
1556         }
1557
1558         fn closing_negotiation_ready(&self) -> bool {
1559                 let is_ready_to_close = match self.channel_state {
1560                         ChannelState::AwaitingChannelReady(flags) =>
1561                                 flags & FundedStateFlags::ALL == FundedStateFlags::LOCAL_SHUTDOWN_SENT | FundedStateFlags::REMOTE_SHUTDOWN_SENT,
1562                         ChannelState::ChannelReady(flags) =>
1563                                 flags == FundedStateFlags::LOCAL_SHUTDOWN_SENT | FundedStateFlags::REMOTE_SHUTDOWN_SENT,
1564                         _ => false,
1565                 };
1566                 self.pending_inbound_htlcs.is_empty() &&
1567                         self.pending_outbound_htlcs.is_empty() &&
1568                         self.pending_update_fee.is_none() &&
1569                         is_ready_to_close
1570         }
1571
1572         /// Returns true if this channel is currently available for use. This is a superset of
1573         /// is_usable() and considers things like the channel being temporarily disabled.
1574         /// Allowed in any state (including after shutdown)
1575         pub fn is_live(&self) -> bool {
1576                 self.is_usable() && !self.channel_state.is_peer_disconnected()
1577         }
1578
1579         // Public utilities:
1580
1581         pub fn channel_id(&self) -> ChannelId {
1582                 self.channel_id
1583         }
1584
1585         // Return the `temporary_channel_id` used during channel establishment.
1586         //
1587         // Will return `None` for channels created prior to LDK version 0.0.115.
1588         pub fn temporary_channel_id(&self) -> Option<ChannelId> {
1589                 self.temporary_channel_id
1590         }
1591
1592         pub fn minimum_depth(&self) -> Option<u32> {
1593                 self.minimum_depth
1594         }
1595
1596         /// Gets the "user_id" value passed into the construction of this channel. It has no special
1597         /// meaning and exists only to allow users to have a persistent identifier of a channel.
1598         pub fn get_user_id(&self) -> u128 {
1599                 self.user_id
1600         }
1601
1602         /// Gets the channel's type
1603         pub fn get_channel_type(&self) -> &ChannelTypeFeatures {
1604                 &self.channel_type
1605         }
1606
1607         /// Gets the channel's `short_channel_id`.
1608         ///
1609         /// Will return `None` if the channel hasn't been confirmed yet.
1610         pub fn get_short_channel_id(&self) -> Option<u64> {
1611                 self.short_channel_id
1612         }
1613
1614         /// Allowed in any state (including after shutdown)
1615         pub fn latest_inbound_scid_alias(&self) -> Option<u64> {
1616                 self.latest_inbound_scid_alias
1617         }
1618
1619         /// Allowed in any state (including after shutdown)
1620         pub fn outbound_scid_alias(&self) -> u64 {
1621                 self.outbound_scid_alias
1622         }
1623
1624         /// Returns the holder signer for this channel.
1625         #[cfg(test)]
1626         pub fn get_signer(&self) -> &ChannelSignerType<SP> {
1627                 return &self.holder_signer
1628         }
1629
1630         /// Only allowed immediately after deserialization if get_outbound_scid_alias returns 0,
1631         /// indicating we were written by LDK prior to 0.0.106 which did not set outbound SCID aliases
1632         /// or prior to any channel actions during `Channel` initialization.
1633         pub fn set_outbound_scid_alias(&mut self, outbound_scid_alias: u64) {
1634                 debug_assert_eq!(self.outbound_scid_alias, 0);
1635                 self.outbound_scid_alias = outbound_scid_alias;
1636         }
1637
1638         /// Returns the funding_txo we either got from our peer, or were given by
1639         /// get_funding_created.
1640         pub fn get_funding_txo(&self) -> Option<OutPoint> {
1641                 self.channel_transaction_parameters.funding_outpoint
1642         }
1643
1644         /// Returns the height in which our funding transaction was confirmed.
1645         pub fn get_funding_tx_confirmation_height(&self) -> Option<u32> {
1646                 let conf_height = self.funding_tx_confirmation_height;
1647                 if conf_height > 0 {
1648                         Some(conf_height)
1649                 } else {
1650                         None
1651                 }
1652         }
1653
1654         /// Returns the block hash in which our funding transaction was confirmed.
1655         pub fn get_funding_tx_confirmed_in(&self) -> Option<BlockHash> {
1656                 self.funding_tx_confirmed_in
1657         }
1658
1659         /// Returns the current number of confirmations on the funding transaction.
1660         pub fn get_funding_tx_confirmations(&self, height: u32) -> u32 {
1661                 if self.funding_tx_confirmation_height == 0 {
1662                         // We either haven't seen any confirmation yet, or observed a reorg.
1663                         return 0;
1664                 }
1665
1666                 height.checked_sub(self.funding_tx_confirmation_height).map_or(0, |c| c + 1)
1667         }
1668
1669         fn get_holder_selected_contest_delay(&self) -> u16 {
1670                 self.channel_transaction_parameters.holder_selected_contest_delay
1671         }
1672
1673         fn get_holder_pubkeys(&self) -> &ChannelPublicKeys {
1674                 &self.channel_transaction_parameters.holder_pubkeys
1675         }
1676
1677         pub fn get_counterparty_selected_contest_delay(&self) -> Option<u16> {
1678                 self.channel_transaction_parameters.counterparty_parameters
1679                         .as_ref().map(|params| params.selected_contest_delay)
1680         }
1681
1682         fn get_counterparty_pubkeys(&self) -> &ChannelPublicKeys {
1683                 &self.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
1684         }
1685
1686         /// Allowed in any state (including after shutdown)
1687         pub fn get_counterparty_node_id(&self) -> PublicKey {
1688                 self.counterparty_node_id
1689         }
1690
1691         /// Allowed in any state (including after shutdown)
1692         pub fn get_holder_htlc_minimum_msat(&self) -> u64 {
1693                 self.holder_htlc_minimum_msat
1694         }
1695
1696         /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
1697         pub fn get_holder_htlc_maximum_msat(&self) -> Option<u64> {
1698                 self.get_htlc_maximum_msat(self.holder_max_htlc_value_in_flight_msat)
1699         }
1700
1701         /// Allowed in any state (including after shutdown)
1702         pub fn get_announced_htlc_max_msat(&self) -> u64 {
1703                 return cmp::min(
1704                         // Upper bound by capacity. We make it a bit less than full capacity to prevent attempts
1705                         // to use full capacity. This is an effort to reduce routing failures, because in many cases
1706                         // channel might have been used to route very small values (either by honest users or as DoS).
1707                         self.channel_value_satoshis * 1000 * 9 / 10,
1708
1709                         self.counterparty_max_htlc_value_in_flight_msat
1710                 );
1711         }
1712
1713         /// Allowed in any state (including after shutdown)
1714         pub fn get_counterparty_htlc_minimum_msat(&self) -> u64 {
1715                 self.counterparty_htlc_minimum_msat
1716         }
1717
1718         /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
1719         pub fn get_counterparty_htlc_maximum_msat(&self) -> Option<u64> {
1720                 self.get_htlc_maximum_msat(self.counterparty_max_htlc_value_in_flight_msat)
1721         }
1722
1723         fn get_htlc_maximum_msat(&self, party_max_htlc_value_in_flight_msat: u64) -> Option<u64> {
1724                 self.counterparty_selected_channel_reserve_satoshis.map(|counterparty_reserve| {
1725                         let holder_reserve = self.holder_selected_channel_reserve_satoshis;
1726                         cmp::min(
1727                                 (self.channel_value_satoshis - counterparty_reserve - holder_reserve) * 1000,
1728                                 party_max_htlc_value_in_flight_msat
1729                         )
1730                 })
1731         }
1732
1733         pub fn get_value_satoshis(&self) -> u64 {
1734                 self.channel_value_satoshis
1735         }
1736
1737         pub fn get_fee_proportional_millionths(&self) -> u32 {
1738                 self.config.options.forwarding_fee_proportional_millionths
1739         }
1740
1741         pub fn get_cltv_expiry_delta(&self) -> u16 {
1742                 cmp::max(self.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
1743         }
1744
1745         pub fn get_max_dust_htlc_exposure_msat<F: Deref>(&self,
1746                 fee_estimator: &LowerBoundedFeeEstimator<F>) -> u64
1747         where F::Target: FeeEstimator
1748         {
1749                 match self.config.options.max_dust_htlc_exposure {
1750                         MaxDustHTLCExposure::FeeRateMultiplier(multiplier) => {
1751                                 let feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(
1752                                         ConfirmationTarget::OnChainSweep) as u64;
1753                                 feerate_per_kw.saturating_mul(multiplier)
1754                         },
1755                         MaxDustHTLCExposure::FixedLimitMsat(limit) => limit,
1756                 }
1757         }
1758
1759         /// Returns the previous [`ChannelConfig`] applied to this channel, if any.
1760         pub fn prev_config(&self) -> Option<ChannelConfig> {
1761                 self.prev_config.map(|prev_config| prev_config.0)
1762         }
1763
1764         // Checks whether we should emit a `ChannelPending` event.
1765         pub(crate) fn should_emit_channel_pending_event(&mut self) -> bool {
1766                 self.is_funding_broadcast() && !self.channel_pending_event_emitted
1767         }
1768
1769         // Returns whether we already emitted a `ChannelPending` event.
1770         pub(crate) fn channel_pending_event_emitted(&self) -> bool {
1771                 self.channel_pending_event_emitted
1772         }
1773
1774         // Remembers that we already emitted a `ChannelPending` event.
1775         pub(crate) fn set_channel_pending_event_emitted(&mut self) {
1776                 self.channel_pending_event_emitted = true;
1777         }
1778
1779         // Checks whether we should emit a `ChannelReady` event.
1780         pub(crate) fn should_emit_channel_ready_event(&mut self) -> bool {
1781                 self.is_usable() && !self.channel_ready_event_emitted
1782         }
1783
1784         // Remembers that we already emitted a `ChannelReady` event.
1785         pub(crate) fn set_channel_ready_event_emitted(&mut self) {
1786                 self.channel_ready_event_emitted = true;
1787         }
1788
1789         /// Tracks the number of ticks elapsed since the previous [`ChannelConfig`] was updated. Once
1790         /// [`EXPIRE_PREV_CONFIG_TICKS`] is reached, the previous config is considered expired and will
1791         /// no longer be considered when forwarding HTLCs.
1792         pub fn maybe_expire_prev_config(&mut self) {
1793                 if self.prev_config.is_none() {
1794                         return;
1795                 }
1796                 let prev_config = self.prev_config.as_mut().unwrap();
1797                 prev_config.1 += 1;
1798                 if prev_config.1 == EXPIRE_PREV_CONFIG_TICKS {
1799                         self.prev_config = None;
1800                 }
1801         }
1802
1803         /// Returns the current [`ChannelConfig`] applied to the channel.
1804         pub fn config(&self) -> ChannelConfig {
1805                 self.config.options
1806         }
1807
1808         /// Updates the channel's config. A bool is returned indicating whether the config update
1809         /// applied resulted in a new ChannelUpdate message.
1810         pub fn update_config(&mut self, config: &ChannelConfig) -> bool {
1811                 let did_channel_update =
1812                         self.config.options.forwarding_fee_proportional_millionths != config.forwarding_fee_proportional_millionths ||
1813                         self.config.options.forwarding_fee_base_msat != config.forwarding_fee_base_msat ||
1814                         self.config.options.cltv_expiry_delta != config.cltv_expiry_delta;
1815                 if did_channel_update {
1816                         self.prev_config = Some((self.config.options, 0));
1817                         // Update the counter, which backs the ChannelUpdate timestamp, to allow the relay
1818                         // policy change to propagate throughout the network.
1819                         self.update_time_counter += 1;
1820                 }
1821                 self.config.options = *config;
1822                 did_channel_update
1823         }
1824
1825         /// Returns true if funding_signed was sent/received and the
1826         /// funding transaction has been broadcast if necessary.
1827         pub fn is_funding_broadcast(&self) -> bool {
1828                 !self.channel_state.is_pre_funded_state() &&
1829                         !matches!(self.channel_state, ChannelState::AwaitingChannelReady(flags) if flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH))
1830         }
1831
1832         /// Transaction nomenclature is somewhat confusing here as there are many different cases - a
1833         /// transaction is referred to as "a's transaction" implying that a will be able to broadcast
1834         /// the transaction. Thus, b will generally be sending a signature over such a transaction to
1835         /// a, and a can revoke the transaction by providing b the relevant per_commitment_secret. As
1836         /// such, a transaction is generally the result of b increasing the amount paid to a (or adding
1837         /// an HTLC to a).
1838         /// @local is used only to convert relevant internal structures which refer to remote vs local
1839         /// to decide value of outputs and direction of HTLCs.
1840         /// @generated_by_local is used to determine *which* HTLCs to include - noting that the HTLC
1841         /// state may indicate that one peer has informed the other that they'd like to add an HTLC but
1842         /// have not yet committed it. Such HTLCs will only be included in transactions which are being
1843         /// generated by the peer which proposed adding the HTLCs, and thus we need to understand both
1844         /// which peer generated this transaction and "to whom" this transaction flows.
1845         #[inline]
1846         fn build_commitment_transaction<L: Deref>(&self, commitment_number: u64, keys: &TxCreationKeys, local: bool, generated_by_local: bool, logger: &L) -> CommitmentStats
1847                 where L::Target: Logger
1848         {
1849                 let mut included_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::new();
1850                 let num_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
1851                 let mut included_non_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
1852
1853                 let broadcaster_dust_limit_satoshis = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
1854                 let mut remote_htlc_total_msat = 0;
1855                 let mut local_htlc_total_msat = 0;
1856                 let mut value_to_self_msat_offset = 0;
1857
1858                 let mut feerate_per_kw = self.feerate_per_kw;
1859                 if let Some((feerate, update_state)) = self.pending_update_fee {
1860                         if match update_state {
1861                                 // Note that these match the inclusion criteria when scanning
1862                                 // pending_inbound_htlcs below.
1863                                 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.is_outbound()); !generated_by_local },
1864                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => { debug_assert!(!self.is_outbound()); !generated_by_local },
1865                                 FeeUpdateState::Outbound => { assert!(self.is_outbound());  generated_by_local },
1866                         } {
1867                                 feerate_per_kw = feerate;
1868                         }
1869                 }
1870
1871                 log_trace!(logger, "Building commitment transaction number {} (really {} xor {}) for channel {} for {}, generated by {} with fee {}...",
1872                         commitment_number, (INITIAL_COMMITMENT_NUMBER - commitment_number),
1873                         get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()),
1874                         &self.channel_id,
1875                         if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);
1876
1877                 macro_rules! get_htlc_in_commitment {
1878                         ($htlc: expr, $offered: expr) => {
1879                                 HTLCOutputInCommitment {
1880                                         offered: $offered,
1881                                         amount_msat: $htlc.amount_msat,
1882                                         cltv_expiry: $htlc.cltv_expiry,
1883                                         payment_hash: $htlc.payment_hash,
1884                                         transaction_output_index: None
1885                                 }
1886                         }
1887                 }
1888
1889                 macro_rules! add_htlc_output {
1890                         ($htlc: expr, $outbound: expr, $source: expr, $state_name: expr) => {
1891                                 if $outbound == local { // "offered HTLC output"
1892                                         let htlc_in_tx = get_htlc_in_commitment!($htlc, true);
1893                                         let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1894                                                 0
1895                                         } else {
1896                                                 feerate_per_kw as u64 * htlc_timeout_tx_weight(self.get_channel_type()) / 1000
1897                                         };
1898                                         if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1899                                                 log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
1900                                                 included_non_dust_htlcs.push((htlc_in_tx, $source));
1901                                         } else {
1902                                                 log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {} due to dust limit", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
1903                                                 included_dust_htlcs.push((htlc_in_tx, $source));
1904                                         }
1905                                 } else {
1906                                         let htlc_in_tx = get_htlc_in_commitment!($htlc, false);
1907                                         let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1908                                                 0
1909                                         } else {
1910                                                 feerate_per_kw as u64 * htlc_success_tx_weight(self.get_channel_type()) / 1000
1911                                         };
1912                                         if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1913                                                 log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
1914                                                 included_non_dust_htlcs.push((htlc_in_tx, $source));
1915                                         } else {
1916                                                 log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, &$htlc.payment_hash, $htlc.amount_msat);
1917                                                 included_dust_htlcs.push((htlc_in_tx, $source));
1918                                         }
1919                                 }
1920                         }
1921                 }
1922
1923                 let mut inbound_htlc_preimages: Vec<PaymentPreimage> = Vec::new();
1924
1925                 for ref htlc in self.pending_inbound_htlcs.iter() {
1926                         let (include, state_name) = match htlc.state {
1927                                 InboundHTLCState::RemoteAnnounced(_) => (!generated_by_local, "RemoteAnnounced"),
1928                                 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => (!generated_by_local, "AwaitingRemoteRevokeToAnnounce"),
1929                                 InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => (true, "AwaitingAnnouncedRemoteRevoke"),
1930                                 InboundHTLCState::Committed => (true, "Committed"),
1931                                 InboundHTLCState::LocalRemoved(_) => (!generated_by_local, "LocalRemoved"),
1932                         };
1933
1934                         if include {
1935                                 add_htlc_output!(htlc, false, None, state_name);
1936                                 remote_htlc_total_msat += htlc.amount_msat;
1937                         } else {
1938                                 log_trace!(logger, "   ...not including inbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, &htlc.payment_hash, htlc.amount_msat, state_name);
1939                                 match &htlc.state {
1940                                         &InboundHTLCState::LocalRemoved(ref reason) => {
1941                                                 if generated_by_local {
1942                                                         if let &InboundHTLCRemovalReason::Fulfill(preimage) = reason {
1943                                                                 inbound_htlc_preimages.push(preimage);
1944                                                                 value_to_self_msat_offset += htlc.amount_msat as i64;
1945                                                         }
1946                                                 }
1947                                         },
1948                                         _ => {},
1949                                 }
1950                         }
1951                 }
1952
1953
1954                 let mut outbound_htlc_preimages: Vec<PaymentPreimage> = Vec::new();
1955
1956                 for ref htlc in self.pending_outbound_htlcs.iter() {
1957                         let (include, state_name) = match htlc.state {
1958                                 OutboundHTLCState::LocalAnnounced(_) => (generated_by_local, "LocalAnnounced"),
1959                                 OutboundHTLCState::Committed => (true, "Committed"),
1960                                 OutboundHTLCState::RemoteRemoved(_) => (generated_by_local, "RemoteRemoved"),
1961                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) => (generated_by_local, "AwaitingRemoteRevokeToRemove"),
1962                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => (false, "AwaitingRemovedRemoteRevoke"),
1963                         };
1964
1965                         let preimage_opt = match htlc.state {
1966                                 OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(p)) => p,
1967                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(p)) => p,
1968                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(p)) => p,
1969                                 _ => None,
1970                         };
1971
1972                         if let Some(preimage) = preimage_opt {
1973                                 outbound_htlc_preimages.push(preimage);
1974                         }
1975
1976                         if include {
1977                                 add_htlc_output!(htlc, true, Some(&htlc.source), state_name);
1978                                 local_htlc_total_msat += htlc.amount_msat;
1979                         } else {
1980                                 log_trace!(logger, "   ...not including outbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, &htlc.payment_hash, htlc.amount_msat, state_name);
1981                                 match htlc.state {
1982                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_))|OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) => {
1983                                                 value_to_self_msat_offset -= htlc.amount_msat as i64;
1984                                         },
1985                                         OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(_)) => {
1986                                                 if !generated_by_local {
1987                                                         value_to_self_msat_offset -= htlc.amount_msat as i64;
1988                                                 }
1989                                         },
1990                                         _ => {},
1991                                 }
1992                         }
1993                 }
1994
1995                 let value_to_self_msat: i64 = (self.value_to_self_msat - local_htlc_total_msat) as i64 + value_to_self_msat_offset;
1996                 assert!(value_to_self_msat >= 0);
1997                 // Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
1998                 // AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
1999                 // "violate" their reserve value by couting those against it. Thus, we have to convert
2000                 // everything to i64 before subtracting as otherwise we can overflow.
2001                 let value_to_remote_msat: i64 = (self.channel_value_satoshis * 1000) as i64 - (self.value_to_self_msat as i64) - (remote_htlc_total_msat as i64) - value_to_self_msat_offset;
2002                 assert!(value_to_remote_msat >= 0);
2003
2004                 #[cfg(debug_assertions)]
2005                 {
2006                         // Make sure that the to_self/to_remote is always either past the appropriate
2007                         // channel_reserve *or* it is making progress towards it.
2008                         let mut broadcaster_max_commitment_tx_output = if generated_by_local {
2009                                 self.holder_max_commitment_tx_output.lock().unwrap()
2010                         } else {
2011                                 self.counterparty_max_commitment_tx_output.lock().unwrap()
2012                         };
2013                         debug_assert!(broadcaster_max_commitment_tx_output.0 <= value_to_self_msat as u64 || value_to_self_msat / 1000 >= self.counterparty_selected_channel_reserve_satoshis.unwrap() as i64);
2014                         broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, value_to_self_msat as u64);
2015                         debug_assert!(broadcaster_max_commitment_tx_output.1 <= value_to_remote_msat as u64 || value_to_remote_msat / 1000 >= self.holder_selected_channel_reserve_satoshis as i64);
2016                         broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, value_to_remote_msat as u64);
2017                 }
2018
2019                 let total_fee_sat = commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), &self.channel_transaction_parameters.channel_type_features);
2020                 let anchors_val = if self.channel_transaction_parameters.channel_type_features.supports_anchors_zero_fee_htlc_tx() { ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 } as i64;
2021                 let (value_to_self, value_to_remote) = if self.is_outbound() {
2022                         (value_to_self_msat / 1000 - anchors_val - total_fee_sat as i64, value_to_remote_msat / 1000)
2023                 } else {
2024                         (value_to_self_msat / 1000, value_to_remote_msat / 1000 - anchors_val - total_fee_sat as i64)
2025                 };
2026
2027                 let mut value_to_a = if local { value_to_self } else { value_to_remote };
2028                 let mut value_to_b = if local { value_to_remote } else { value_to_self };
2029                 let (funding_pubkey_a, funding_pubkey_b) = if local {
2030                         (self.get_holder_pubkeys().funding_pubkey, self.get_counterparty_pubkeys().funding_pubkey)
2031                 } else {
2032                         (self.get_counterparty_pubkeys().funding_pubkey, self.get_holder_pubkeys().funding_pubkey)
2033                 };
2034
2035                 if value_to_a >= (broadcaster_dust_limit_satoshis as i64) {
2036                         log_trace!(logger, "   ...including {} output with value {}", if local { "to_local" } else { "to_remote" }, value_to_a);
2037                 } else {
2038                         value_to_a = 0;
2039                 }
2040
2041                 if value_to_b >= (broadcaster_dust_limit_satoshis as i64) {
2042                         log_trace!(logger, "   ...including {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
2043                 } else {
2044                         value_to_b = 0;
2045                 }
2046
2047                 let num_nondust_htlcs = included_non_dust_htlcs.len();
2048
2049                 let channel_parameters =
2050                         if local { self.channel_transaction_parameters.as_holder_broadcastable() }
2051                         else { self.channel_transaction_parameters.as_counterparty_broadcastable() };
2052                 let tx = CommitmentTransaction::new_with_auxiliary_htlc_data(commitment_number,
2053                                                                              value_to_a as u64,
2054                                                                              value_to_b as u64,
2055                                                                              funding_pubkey_a,
2056                                                                              funding_pubkey_b,
2057                                                                              keys.clone(),
2058                                                                              feerate_per_kw,
2059                                                                              &mut included_non_dust_htlcs,
2060                                                                              &channel_parameters
2061                 );
2062                 let mut htlcs_included = included_non_dust_htlcs;
2063                 // The unwrap is safe, because all non-dust HTLCs have been assigned an output index
2064                 htlcs_included.sort_unstable_by_key(|h| h.0.transaction_output_index.unwrap());
2065                 htlcs_included.append(&mut included_dust_htlcs);
2066
2067                 CommitmentStats {
2068                         tx,
2069                         feerate_per_kw,
2070                         total_fee_sat,
2071                         num_nondust_htlcs,
2072                         htlcs_included,
2073                         local_balance_msat: value_to_self_msat as u64,
2074                         remote_balance_msat: value_to_remote_msat as u64,
2075                         inbound_htlc_preimages,
2076                         outbound_htlc_preimages,
2077                 }
2078         }
2079
2080         #[inline]
2081         /// Creates a set of keys for build_commitment_transaction to generate a transaction which our
2082         /// counterparty will sign (ie DO NOT send signatures over a transaction created by this to
2083         /// our counterparty!)
2084         /// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
2085         /// TODO Some magic rust shit to compile-time check this?
2086         fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
2087                 let per_commitment_point = self.holder_signer.as_ref().get_per_commitment_point(commitment_number, &self.secp_ctx);
2088                 let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
2089                 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
2090                 let counterparty_pubkeys = self.get_counterparty_pubkeys();
2091
2092                 TxCreationKeys::derive_new(&self.secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint)
2093         }
2094
2095         #[inline]
2096         /// Creates a set of keys for build_commitment_transaction to generate a transaction which we
2097         /// will sign and send to our counterparty.
2098         /// If an Err is returned, it is a ChannelError::Close (for get_funding_created)
2099         fn build_remote_transaction_keys(&self) -> TxCreationKeys {
2100                 let revocation_basepoint = &self.get_holder_pubkeys().revocation_basepoint;
2101                 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
2102                 let counterparty_pubkeys = self.get_counterparty_pubkeys();
2103
2104                 TxCreationKeys::derive_new(&self.secp_ctx, &self.counterparty_cur_commitment_point.unwrap(), &counterparty_pubkeys.delayed_payment_basepoint, &counterparty_pubkeys.htlc_basepoint, revocation_basepoint, htlc_basepoint)
2105         }
2106
2107         /// Gets the redeemscript for the funding transaction output (ie the funding transaction output
2108         /// pays to get_funding_redeemscript().to_v0_p2wsh()).
2109         /// Panics if called before accept_channel/InboundV1Channel::new
2110         pub fn get_funding_redeemscript(&self) -> ScriptBuf {
2111                 make_funding_redeemscript(&self.get_holder_pubkeys().funding_pubkey, self.counterparty_funding_pubkey())
2112         }
2113
2114         fn counterparty_funding_pubkey(&self) -> &PublicKey {
2115                 &self.get_counterparty_pubkeys().funding_pubkey
2116         }
2117
2118         pub fn get_feerate_sat_per_1000_weight(&self) -> u32 {
2119                 self.feerate_per_kw
2120         }
2121
2122         pub fn get_dust_buffer_feerate(&self, outbound_feerate_update: Option<u32>) -> u32 {
2123                 // When calculating our exposure to dust HTLCs, we assume that the channel feerate
2124                 // may, at any point, increase by at least 10 sat/vB (i.e 2530 sat/kWU) or 25%,
2125                 // whichever is higher. This ensures that we aren't suddenly exposed to significantly
2126                 // more dust balance if the feerate increases when we have several HTLCs pending
2127                 // which are near the dust limit.
2128                 let mut feerate_per_kw = self.feerate_per_kw;
2129                 // If there's a pending update fee, use it to ensure we aren't under-estimating
2130                 // potential feerate updates coming soon.
2131                 if let Some((feerate, _)) = self.pending_update_fee {
2132                         feerate_per_kw = cmp::max(feerate_per_kw, feerate);
2133                 }
2134                 if let Some(feerate) = outbound_feerate_update {
2135                         feerate_per_kw = cmp::max(feerate_per_kw, feerate);
2136                 }
2137                 let feerate_plus_quarter = feerate_per_kw.checked_mul(1250).map(|v| v / 1000);
2138                 cmp::max(2530, feerate_plus_quarter.unwrap_or(u32::max_value()))
2139         }
2140
2141         /// Get forwarding information for the counterparty.
2142         pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
2143                 self.counterparty_forwarding_info.clone()
2144         }
2145
2146         /// Returns a HTLCStats about inbound pending htlcs
2147         fn get_inbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
2148                 let context = self;
2149                 let mut stats = HTLCStats {
2150                         pending_htlcs: context.pending_inbound_htlcs.len() as u32,
2151                         pending_htlcs_value_msat: 0,
2152                         on_counterparty_tx_dust_exposure_msat: 0,
2153                         on_holder_tx_dust_exposure_msat: 0,
2154                         holding_cell_msat: 0,
2155                         on_holder_tx_holding_cell_htlcs_count: 0,
2156                 };
2157
2158                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2159                         (0, 0)
2160                 } else {
2161                         let dust_buffer_feerate = context.get_dust_buffer_feerate(outbound_feerate_update) as u64;
2162                         (dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000,
2163                                 dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000)
2164                 };
2165                 let counterparty_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.counterparty_dust_limit_satoshis;
2166                 let holder_dust_limit_success_sat = htlc_success_dust_limit + context.holder_dust_limit_satoshis;
2167                 for ref htlc in context.pending_inbound_htlcs.iter() {
2168                         stats.pending_htlcs_value_msat += htlc.amount_msat;
2169                         if htlc.amount_msat / 1000 < counterparty_dust_limit_timeout_sat {
2170                                 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
2171                         }
2172                         if htlc.amount_msat / 1000 < holder_dust_limit_success_sat {
2173                                 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
2174                         }
2175                 }
2176                 stats
2177         }
2178
2179         /// Returns a HTLCStats about pending outbound htlcs, *including* pending adds in our holding cell.
2180         fn get_outbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
2181                 let context = self;
2182                 let mut stats = HTLCStats {
2183                         pending_htlcs: context.pending_outbound_htlcs.len() as u32,
2184                         pending_htlcs_value_msat: 0,
2185                         on_counterparty_tx_dust_exposure_msat: 0,
2186                         on_holder_tx_dust_exposure_msat: 0,
2187                         holding_cell_msat: 0,
2188                         on_holder_tx_holding_cell_htlcs_count: 0,
2189                 };
2190
2191                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2192                         (0, 0)
2193                 } else {
2194                         let dust_buffer_feerate = context.get_dust_buffer_feerate(outbound_feerate_update) as u64;
2195                         (dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000,
2196                                 dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000)
2197                 };
2198                 let counterparty_dust_limit_success_sat = htlc_success_dust_limit + context.counterparty_dust_limit_satoshis;
2199                 let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.holder_dust_limit_satoshis;
2200                 for ref htlc in context.pending_outbound_htlcs.iter() {
2201                         stats.pending_htlcs_value_msat += htlc.amount_msat;
2202                         if htlc.amount_msat / 1000 < counterparty_dust_limit_success_sat {
2203                                 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
2204                         }
2205                         if htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat {
2206                                 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
2207                         }
2208                 }
2209
2210                 for update in context.holding_cell_htlc_updates.iter() {
2211                         if let &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, .. } = update {
2212                                 stats.pending_htlcs += 1;
2213                                 stats.pending_htlcs_value_msat += amount_msat;
2214                                 stats.holding_cell_msat += amount_msat;
2215                                 if *amount_msat / 1000 < counterparty_dust_limit_success_sat {
2216                                         stats.on_counterparty_tx_dust_exposure_msat += amount_msat;
2217                                 }
2218                                 if *amount_msat / 1000 < holder_dust_limit_timeout_sat {
2219                                         stats.on_holder_tx_dust_exposure_msat += amount_msat;
2220                                 } else {
2221                                         stats.on_holder_tx_holding_cell_htlcs_count += 1;
2222                                 }
2223                         }
2224                 }
2225                 stats
2226         }
2227
2228         /// Returns information on all pending inbound HTLCs.
2229         pub fn get_pending_inbound_htlc_details(&self) -> Vec<InboundHTLCDetails> {
2230                 let mut holding_cell_states = new_hash_map();
2231                 for holding_cell_update in self.holding_cell_htlc_updates.iter() {
2232                         match holding_cell_update {
2233                                 HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
2234                                         holding_cell_states.insert(
2235                                                 htlc_id,
2236                                                 InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFulfill,
2237                                         );
2238                                 },
2239                                 HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
2240                                         holding_cell_states.insert(
2241                                                 htlc_id,
2242                                                 InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail,
2243                                         );
2244                                 },
2245                                 HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } => {
2246                                         holding_cell_states.insert(
2247                                                 htlc_id,
2248                                                 InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail,
2249                                         );
2250                                 },
2251                                 // Outbound HTLC.
2252                                 HTLCUpdateAwaitingACK::AddHTLC { .. } => {},
2253                         }
2254                 }
2255                 let mut inbound_details = Vec::new();
2256                 let htlc_success_dust_limit = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2257                         0
2258                 } else {
2259                         let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
2260                         dust_buffer_feerate * htlc_success_tx_weight(self.get_channel_type()) / 1000
2261                 };
2262                 let holder_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
2263                 for htlc in self.pending_inbound_htlcs.iter() {
2264                         if let Some(state_details) = (&htlc.state).into() {
2265                                 inbound_details.push(InboundHTLCDetails{
2266                                         htlc_id: htlc.htlc_id,
2267                                         amount_msat: htlc.amount_msat,
2268                                         cltv_expiry: htlc.cltv_expiry,
2269                                         payment_hash: htlc.payment_hash,
2270                                         state: Some(holding_cell_states.remove(&htlc.htlc_id).unwrap_or(state_details)),
2271                                         is_dust: htlc.amount_msat / 1000 < holder_dust_limit_success_sat,
2272                                 });
2273                         }
2274                 }
2275                 inbound_details
2276         }
2277
2278         /// Returns information on all pending outbound HTLCs.
2279         pub fn get_pending_outbound_htlc_details(&self) -> Vec<OutboundHTLCDetails> {
2280                 let mut outbound_details = Vec::new();
2281                 let htlc_timeout_dust_limit = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2282                         0
2283                 } else {
2284                         let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
2285                         dust_buffer_feerate * htlc_success_tx_weight(self.get_channel_type()) / 1000
2286                 };
2287                 let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
2288                 for htlc in self.pending_outbound_htlcs.iter() {
2289                         outbound_details.push(OutboundHTLCDetails{
2290                                 htlc_id: Some(htlc.htlc_id),
2291                                 amount_msat: htlc.amount_msat,
2292                                 cltv_expiry: htlc.cltv_expiry,
2293                                 payment_hash: htlc.payment_hash,
2294                                 skimmed_fee_msat: htlc.skimmed_fee_msat,
2295                                 state: Some((&htlc.state).into()),
2296                                 is_dust: htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat,
2297                         });
2298                 }
2299                 for holding_cell_update in self.holding_cell_htlc_updates.iter() {
2300                         if let HTLCUpdateAwaitingACK::AddHTLC {
2301                                 amount_msat,
2302                                 cltv_expiry,
2303                                 payment_hash,
2304                                 skimmed_fee_msat,
2305                                 ..
2306                         } = *holding_cell_update {
2307                                 outbound_details.push(OutboundHTLCDetails{
2308                                         htlc_id: None,
2309                                         amount_msat: amount_msat,
2310                                         cltv_expiry: cltv_expiry,
2311                                         payment_hash: payment_hash,
2312                                         skimmed_fee_msat: skimmed_fee_msat,
2313                                         state: Some(OutboundHTLCStateDetails::AwaitingRemoteRevokeToAdd),
2314                                         is_dust: amount_msat / 1000 < holder_dust_limit_timeout_sat,
2315                                 });
2316                         }
2317                 }
2318                 outbound_details
2319         }
2320
2321         /// Get the available balances, see [`AvailableBalances`]'s fields for more info.
2322         /// Doesn't bother handling the
2323         /// if-we-removed-it-already-but-haven't-fully-resolved-they-can-still-send-an-inbound-HTLC
2324         /// corner case properly.
2325         pub fn get_available_balances<F: Deref>(&self, fee_estimator: &LowerBoundedFeeEstimator<F>)
2326         -> AvailableBalances
2327         where F::Target: FeeEstimator
2328         {
2329                 let context = &self;
2330                 // Note that we have to handle overflow due to the above case.
2331                 let inbound_stats = context.get_inbound_pending_htlc_stats(None);
2332                 let outbound_stats = context.get_outbound_pending_htlc_stats(None);
2333
2334                 let mut balance_msat = context.value_to_self_msat;
2335                 for ref htlc in context.pending_inbound_htlcs.iter() {
2336                         if let InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) = htlc.state {
2337                                 balance_msat += htlc.amount_msat;
2338                         }
2339                 }
2340                 balance_msat -= outbound_stats.pending_htlcs_value_msat;
2341
2342                 let outbound_capacity_msat = context.value_to_self_msat
2343                                 .saturating_sub(outbound_stats.pending_htlcs_value_msat)
2344                                 .saturating_sub(
2345                                         context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000);
2346
2347                 let mut available_capacity_msat = outbound_capacity_msat;
2348
2349                 let anchor_outputs_value_msat = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2350                         ANCHOR_OUTPUT_VALUE_SATOSHI * 2 * 1000
2351                 } else {
2352                         0
2353                 };
2354                 if context.is_outbound() {
2355                         // We should mind channel commit tx fee when computing how much of the available capacity
2356                         // can be used in the next htlc. Mirrors the logic in send_htlc.
2357                         //
2358                         // The fee depends on whether the amount we will be sending is above dust or not,
2359                         // and the answer will in turn change the amount itself â€” making it a circular
2360                         // dependency.
2361                         // This complicates the computation around dust-values, up to the one-htlc-value.
2362                         let mut real_dust_limit_timeout_sat = context.holder_dust_limit_satoshis;
2363                         if !context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2364                                 real_dust_limit_timeout_sat += context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000;
2365                         }
2366
2367                         let htlc_above_dust = HTLCCandidate::new(real_dust_limit_timeout_sat * 1000, HTLCInitiator::LocalOffered);
2368                         let mut max_reserved_commit_tx_fee_msat = context.next_local_commit_tx_fee_msat(htlc_above_dust, Some(()));
2369                         let htlc_dust = HTLCCandidate::new(real_dust_limit_timeout_sat * 1000 - 1, HTLCInitiator::LocalOffered);
2370                         let mut min_reserved_commit_tx_fee_msat = context.next_local_commit_tx_fee_msat(htlc_dust, Some(()));
2371                         if !context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2372                                 max_reserved_commit_tx_fee_msat *= FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
2373                                 min_reserved_commit_tx_fee_msat *= FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
2374                         }
2375
2376                         // We will first subtract the fee as if we were above-dust. Then, if the resulting
2377                         // value ends up being below dust, we have this fee available again. In that case,
2378                         // match the value to right-below-dust.
2379                         let mut capacity_minus_commitment_fee_msat: i64 = available_capacity_msat as i64 -
2380                                 max_reserved_commit_tx_fee_msat as i64 - anchor_outputs_value_msat as i64;
2381                         if capacity_minus_commitment_fee_msat < (real_dust_limit_timeout_sat as i64) * 1000 {
2382                                 let one_htlc_difference_msat = max_reserved_commit_tx_fee_msat - min_reserved_commit_tx_fee_msat;
2383                                 debug_assert!(one_htlc_difference_msat != 0);
2384                                 capacity_minus_commitment_fee_msat += one_htlc_difference_msat as i64;
2385                                 capacity_minus_commitment_fee_msat = cmp::min(real_dust_limit_timeout_sat as i64 * 1000 - 1, capacity_minus_commitment_fee_msat);
2386                                 available_capacity_msat = cmp::max(0, cmp::min(capacity_minus_commitment_fee_msat, available_capacity_msat as i64)) as u64;
2387                         } else {
2388                                 available_capacity_msat = capacity_minus_commitment_fee_msat as u64;
2389                         }
2390                 } else {
2391                         // If the channel is inbound (i.e. counterparty pays the fee), we need to make sure
2392                         // sending a new HTLC won't reduce their balance below our reserve threshold.
2393                         let mut real_dust_limit_success_sat = context.counterparty_dust_limit_satoshis;
2394                         if !context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2395                                 real_dust_limit_success_sat += context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000;
2396                         }
2397
2398                         let htlc_above_dust = HTLCCandidate::new(real_dust_limit_success_sat * 1000, HTLCInitiator::LocalOffered);
2399                         let max_reserved_commit_tx_fee_msat = context.next_remote_commit_tx_fee_msat(htlc_above_dust, None);
2400
2401                         let holder_selected_chan_reserve_msat = context.holder_selected_channel_reserve_satoshis * 1000;
2402                         let remote_balance_msat = (context.channel_value_satoshis * 1000 - context.value_to_self_msat)
2403                                 .saturating_sub(inbound_stats.pending_htlcs_value_msat);
2404
2405                         if remote_balance_msat < max_reserved_commit_tx_fee_msat + holder_selected_chan_reserve_msat + anchor_outputs_value_msat {
2406                                 // If another HTLC's fee would reduce the remote's balance below the reserve limit
2407                                 // we've selected for them, we can only send dust HTLCs.
2408                                 available_capacity_msat = cmp::min(available_capacity_msat, real_dust_limit_success_sat * 1000 - 1);
2409                         }
2410                 }
2411
2412                 let mut next_outbound_htlc_minimum_msat = context.counterparty_htlc_minimum_msat;
2413
2414                 // If we get close to our maximum dust exposure, we end up in a situation where we can send
2415                 // between zero and the remaining dust exposure limit remaining OR above the dust limit.
2416                 // Because we cannot express this as a simple min/max, we prefer to tell the user they can
2417                 // send above the dust limit (as the router can always overpay to meet the dust limit).
2418                 let mut remaining_msat_below_dust_exposure_limit = None;
2419                 let mut dust_exposure_dust_limit_msat = 0;
2420                 let max_dust_htlc_exposure_msat = context.get_max_dust_htlc_exposure_msat(fee_estimator);
2421
2422                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2423                         (context.counterparty_dust_limit_satoshis, context.holder_dust_limit_satoshis)
2424                 } else {
2425                         let dust_buffer_feerate = context.get_dust_buffer_feerate(None) as u64;
2426                         (context.counterparty_dust_limit_satoshis + dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000,
2427                          context.holder_dust_limit_satoshis       + dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
2428                 };
2429                 let on_counterparty_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
2430                 if on_counterparty_dust_htlc_exposure_msat as i64 + htlc_success_dust_limit as i64 * 1000 - 1 > max_dust_htlc_exposure_msat.try_into().unwrap_or(i64::max_value()) {
2431                         remaining_msat_below_dust_exposure_limit =
2432                                 Some(max_dust_htlc_exposure_msat.saturating_sub(on_counterparty_dust_htlc_exposure_msat));
2433                         dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, htlc_success_dust_limit * 1000);
2434                 }
2435
2436                 let on_holder_dust_htlc_exposure_msat = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
2437                 if on_holder_dust_htlc_exposure_msat as i64 + htlc_timeout_dust_limit as i64 * 1000 - 1 > max_dust_htlc_exposure_msat.try_into().unwrap_or(i64::max_value()) {
2438                         remaining_msat_below_dust_exposure_limit = Some(cmp::min(
2439                                 remaining_msat_below_dust_exposure_limit.unwrap_or(u64::max_value()),
2440                                 max_dust_htlc_exposure_msat.saturating_sub(on_holder_dust_htlc_exposure_msat)));
2441                         dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, htlc_timeout_dust_limit * 1000);
2442                 }
2443
2444                 if let Some(remaining_limit_msat) = remaining_msat_below_dust_exposure_limit {
2445                         if available_capacity_msat < dust_exposure_dust_limit_msat {
2446                                 available_capacity_msat = cmp::min(available_capacity_msat, remaining_limit_msat);
2447                         } else {
2448                                 next_outbound_htlc_minimum_msat = cmp::max(next_outbound_htlc_minimum_msat, dust_exposure_dust_limit_msat);
2449                         }
2450                 }
2451
2452                 available_capacity_msat = cmp::min(available_capacity_msat,
2453                         context.counterparty_max_htlc_value_in_flight_msat - outbound_stats.pending_htlcs_value_msat);
2454
2455                 if outbound_stats.pending_htlcs + 1 > context.counterparty_max_accepted_htlcs as u32 {
2456                         available_capacity_msat = 0;
2457                 }
2458
2459                 AvailableBalances {
2460                         inbound_capacity_msat: cmp::max(context.channel_value_satoshis as i64 * 1000
2461                                         - context.value_to_self_msat as i64
2462                                         - context.get_inbound_pending_htlc_stats(None).pending_htlcs_value_msat as i64
2463                                         - context.holder_selected_channel_reserve_satoshis as i64 * 1000,
2464                                 0) as u64,
2465                         outbound_capacity_msat,
2466                         next_outbound_htlc_limit_msat: available_capacity_msat,
2467                         next_outbound_htlc_minimum_msat,
2468                         balance_msat,
2469                 }
2470         }
2471
2472         pub fn get_holder_counterparty_selected_channel_reserve_satoshis(&self) -> (u64, Option<u64>) {
2473                 let context = &self;
2474                 (context.holder_selected_channel_reserve_satoshis, context.counterparty_selected_channel_reserve_satoshis)
2475         }
2476
2477         /// Get the commitment tx fee for the local's (i.e. our) next commitment transaction based on the
2478         /// number of pending HTLCs that are on track to be in our next commitment tx.
2479         ///
2480         /// Optionally includes the `HTLCCandidate` given by `htlc` and an additional non-dust HTLC if
2481         /// `fee_spike_buffer_htlc` is `Some`.
2482         ///
2483         /// The first extra HTLC is useful for determining whether we can accept a further HTLC, the
2484         /// second allows for creating a buffer to ensure a further HTLC can always be accepted/added.
2485         ///
2486         /// Dust HTLCs are excluded.
2487         fn next_local_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
2488                 let context = &self;
2489                 assert!(context.is_outbound());
2490
2491                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2492                         (0, 0)
2493                 } else {
2494                         (context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000,
2495                                 context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
2496                 };
2497                 let real_dust_limit_success_sat = htlc_success_dust_limit + context.holder_dust_limit_satoshis;
2498                 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.holder_dust_limit_satoshis;
2499
2500                 let mut addl_htlcs = 0;
2501                 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
2502                 match htlc.origin {
2503                         HTLCInitiator::LocalOffered => {
2504                                 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
2505                                         addl_htlcs += 1;
2506                                 }
2507                         },
2508                         HTLCInitiator::RemoteOffered => {
2509                                 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
2510                                         addl_htlcs += 1;
2511                                 }
2512                         }
2513                 }
2514
2515                 let mut included_htlcs = 0;
2516                 for ref htlc in context.pending_inbound_htlcs.iter() {
2517                         if htlc.amount_msat / 1000 < real_dust_limit_success_sat {
2518                                 continue
2519                         }
2520                         // We include LocalRemoved HTLCs here because we may still need to broadcast a commitment
2521                         // transaction including this HTLC if it times out before they RAA.
2522                         included_htlcs += 1;
2523                 }
2524
2525                 for ref htlc in context.pending_outbound_htlcs.iter() {
2526                         if htlc.amount_msat / 1000 < real_dust_limit_timeout_sat {
2527                                 continue
2528                         }
2529                         match htlc.state {
2530                                 OutboundHTLCState::LocalAnnounced {..} => included_htlcs += 1,
2531                                 OutboundHTLCState::Committed => included_htlcs += 1,
2532                                 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
2533                                 // We don't include AwaitingRemoteRevokeToRemove HTLCs because our next commitment
2534                                 // transaction won't be generated until they send us their next RAA, which will mean
2535                                 // dropping any HTLCs in this state.
2536                                 _ => {},
2537                         }
2538                 }
2539
2540                 for htlc in context.holding_cell_htlc_updates.iter() {
2541                         match htlc {
2542                                 &HTLCUpdateAwaitingACK::AddHTLC { amount_msat, .. } => {
2543                                         if amount_msat / 1000 < real_dust_limit_timeout_sat {
2544                                                 continue
2545                                         }
2546                                         included_htlcs += 1
2547                                 },
2548                                 _ => {}, // Don't include claims/fails that are awaiting ack, because once we get the
2549                                          // ack we're guaranteed to never include them in commitment txs anymore.
2550                         }
2551                 }
2552
2553                 let num_htlcs = included_htlcs + addl_htlcs;
2554                 let res = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs, &context.channel_type);
2555                 #[cfg(any(test, fuzzing))]
2556                 {
2557                         let mut fee = res;
2558                         if fee_spike_buffer_htlc.is_some() {
2559                                 fee = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs - 1, &context.channel_type);
2560                         }
2561                         let total_pending_htlcs = context.pending_inbound_htlcs.len() + context.pending_outbound_htlcs.len()
2562                                 + context.holding_cell_htlc_updates.len();
2563                         let commitment_tx_info = CommitmentTxInfoCached {
2564                                 fee,
2565                                 total_pending_htlcs,
2566                                 next_holder_htlc_id: match htlc.origin {
2567                                         HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
2568                                         HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
2569                                 },
2570                                 next_counterparty_htlc_id: match htlc.origin {
2571                                         HTLCInitiator::LocalOffered => context.next_counterparty_htlc_id,
2572                                         HTLCInitiator::RemoteOffered => context.next_counterparty_htlc_id + 1,
2573                                 },
2574                                 feerate: context.feerate_per_kw,
2575                         };
2576                         *context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
2577                 }
2578                 res
2579         }
2580
2581         /// Get the commitment tx fee for the remote's next commitment transaction based on the number of
2582         /// pending HTLCs that are on track to be in their next commitment tx
2583         ///
2584         /// Optionally includes the `HTLCCandidate` given by `htlc` and an additional non-dust HTLC if
2585         /// `fee_spike_buffer_htlc` is `Some`.
2586         ///
2587         /// The first extra HTLC is useful for determining whether we can accept a further HTLC, the
2588         /// second allows for creating a buffer to ensure a further HTLC can always be accepted/added.
2589         ///
2590         /// Dust HTLCs are excluded.
2591         fn next_remote_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
2592                 let context = &self;
2593                 assert!(!context.is_outbound());
2594
2595                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2596                         (0, 0)
2597                 } else {
2598                         (context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000,
2599                                 context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
2600                 };
2601                 let real_dust_limit_success_sat = htlc_success_dust_limit + context.counterparty_dust_limit_satoshis;
2602                 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.counterparty_dust_limit_satoshis;
2603
2604                 let mut addl_htlcs = 0;
2605                 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
2606                 match htlc.origin {
2607                         HTLCInitiator::LocalOffered => {
2608                                 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
2609                                         addl_htlcs += 1;
2610                                 }
2611                         },
2612                         HTLCInitiator::RemoteOffered => {
2613                                 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
2614                                         addl_htlcs += 1;
2615                                 }
2616                         }
2617                 }
2618
2619                 // When calculating the set of HTLCs which will be included in their next commitment_signed, all
2620                 // non-dust inbound HTLCs are included (as all states imply it will be included) and only
2621                 // committed outbound HTLCs, see below.
2622                 let mut included_htlcs = 0;
2623                 for ref htlc in context.pending_inbound_htlcs.iter() {
2624                         if htlc.amount_msat / 1000 <= real_dust_limit_timeout_sat {
2625                                 continue
2626                         }
2627                         included_htlcs += 1;
2628                 }
2629
2630                 for ref htlc in context.pending_outbound_htlcs.iter() {
2631                         if htlc.amount_msat / 1000 <= real_dust_limit_success_sat {
2632                                 continue
2633                         }
2634                         // We only include outbound HTLCs if it will not be included in their next commitment_signed,
2635                         // i.e. if they've responded to us with an RAA after announcement.
2636                         match htlc.state {
2637                                 OutboundHTLCState::Committed => included_htlcs += 1,
2638                                 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
2639                                 OutboundHTLCState::LocalAnnounced { .. } => included_htlcs += 1,
2640                                 _ => {},
2641                         }
2642                 }
2643
2644                 let num_htlcs = included_htlcs + addl_htlcs;
2645                 let res = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs, &context.channel_type);
2646                 #[cfg(any(test, fuzzing))]
2647                 {
2648                         let mut fee = res;
2649                         if fee_spike_buffer_htlc.is_some() {
2650                                 fee = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs - 1, &context.channel_type);
2651                         }
2652                         let total_pending_htlcs = context.pending_inbound_htlcs.len() + context.pending_outbound_htlcs.len();
2653                         let commitment_tx_info = CommitmentTxInfoCached {
2654                                 fee,
2655                                 total_pending_htlcs,
2656                                 next_holder_htlc_id: match htlc.origin {
2657                                         HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
2658                                         HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
2659                                 },
2660                                 next_counterparty_htlc_id: match htlc.origin {
2661                                         HTLCInitiator::LocalOffered => context.next_counterparty_htlc_id,
2662                                         HTLCInitiator::RemoteOffered => context.next_counterparty_htlc_id + 1,
2663                                 },
2664                                 feerate: context.feerate_per_kw,
2665                         };
2666                         *context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
2667                 }
2668                 res
2669         }
2670
2671         fn if_unbroadcasted_funding<F, O>(&self, f: F) -> Option<O> where F: Fn() -> Option<O> {
2672                 match self.channel_state {
2673                         ChannelState::FundingNegotiated => f(),
2674                         ChannelState::AwaitingChannelReady(flags) =>
2675                                 if flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH) ||
2676                                         flags.is_set(FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS.into())
2677                                 {
2678                                         f()
2679                                 } else {
2680                                         None
2681                                 },
2682                         _ => None,
2683                 }
2684         }
2685
2686         /// Returns the transaction if there is a pending funding transaction that is yet to be
2687         /// broadcast.
2688         pub fn unbroadcasted_funding(&self) -> Option<Transaction> {
2689                 self.if_unbroadcasted_funding(|| self.funding_transaction.clone())
2690         }
2691
2692         /// Returns the transaction ID if there is a pending funding transaction that is yet to be
2693         /// broadcast.
2694         pub fn unbroadcasted_funding_txid(&self) -> Option<Txid> {
2695                 self.if_unbroadcasted_funding(||
2696                         self.channel_transaction_parameters.funding_outpoint.map(|txo| txo.txid)
2697                 )
2698         }
2699
2700         /// Returns whether the channel is funded in a batch.
2701         pub fn is_batch_funding(&self) -> bool {
2702                 self.is_batch_funding.is_some()
2703         }
2704
2705         /// Returns the transaction ID if there is a pending batch funding transaction that is yet to be
2706         /// broadcast.
2707         pub fn unbroadcasted_batch_funding_txid(&self) -> Option<Txid> {
2708                 self.unbroadcasted_funding_txid().filter(|_| self.is_batch_funding())
2709         }
2710
2711         /// Gets the latest commitment transaction and any dependent transactions for relay (forcing
2712         /// shutdown of this channel - no more calls into this Channel may be made afterwards except
2713         /// those explicitly stated to be allowed after shutdown completes, eg some simple getters).
2714         /// Also returns the list of payment_hashes for channels which we can safely fail backwards
2715         /// immediately (others we will have to allow to time out).
2716         pub fn force_shutdown(&mut self, should_broadcast: bool, closure_reason: ClosureReason) -> ShutdownResult {
2717                 // Note that we MUST only generate a monitor update that indicates force-closure - we're
2718                 // called during initialization prior to the chain_monitor in the encompassing ChannelManager
2719                 // being fully configured in some cases. Thus, its likely any monitor events we generate will
2720                 // be delayed in being processed! See the docs for `ChannelManagerReadArgs` for more.
2721                 assert!(!matches!(self.channel_state, ChannelState::ShutdownComplete));
2722
2723                 // We go ahead and "free" any holding cell HTLCs or HTLCs we haven't yet committed to and
2724                 // return them to fail the payment.
2725                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
2726                 let counterparty_node_id = self.get_counterparty_node_id();
2727                 for htlc_update in self.holding_cell_htlc_updates.drain(..) {
2728                         match htlc_update {
2729                                 HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. } => {
2730                                         dropped_outbound_htlcs.push((source, payment_hash, counterparty_node_id, self.channel_id));
2731                                 },
2732                                 _ => {}
2733                         }
2734                 }
2735                 let monitor_update = if let Some(funding_txo) = self.get_funding_txo() {
2736                         // If we haven't yet exchanged funding signatures (ie channel_state < AwaitingChannelReady),
2737                         // returning a channel monitor update here would imply a channel monitor update before
2738                         // we even registered the channel monitor to begin with, which is invalid.
2739                         // Thus, if we aren't actually at a point where we could conceivably broadcast the
2740                         // funding transaction, don't return a funding txo (which prevents providing the
2741                         // monitor update to the user, even if we return one).
2742                         // See test_duplicate_chan_id and test_pre_lockin_no_chan_closed_update for more.
2743                         if !self.channel_state.is_pre_funded_state() {
2744                                 self.latest_monitor_update_id = CLOSED_CHANNEL_UPDATE_ID;
2745                                 Some((self.get_counterparty_node_id(), funding_txo, self.channel_id(), ChannelMonitorUpdate {
2746                                         update_id: self.latest_monitor_update_id,
2747                                         counterparty_node_id: Some(self.counterparty_node_id),
2748                                         updates: vec![ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast }],
2749                                         channel_id: Some(self.channel_id()),
2750                                 }))
2751                         } else { None }
2752                 } else { None };
2753                 let unbroadcasted_batch_funding_txid = self.unbroadcasted_batch_funding_txid();
2754                 let unbroadcasted_funding_tx = self.unbroadcasted_funding();
2755
2756                 self.channel_state = ChannelState::ShutdownComplete;
2757                 self.update_time_counter += 1;
2758                 ShutdownResult {
2759                         closure_reason,
2760                         monitor_update,
2761                         dropped_outbound_htlcs,
2762                         unbroadcasted_batch_funding_txid,
2763                         channel_id: self.channel_id,
2764                         user_channel_id: self.user_id,
2765                         channel_capacity_satoshis: self.channel_value_satoshis,
2766                         counterparty_node_id: self.counterparty_node_id,
2767                         unbroadcasted_funding_tx,
2768                         channel_funding_txo: self.get_funding_txo(),
2769                 }
2770         }
2771
2772         /// Only allowed after [`Self::channel_transaction_parameters`] is set.
2773         fn get_funding_signed_msg<L: Deref>(&mut self, logger: &L) -> (CommitmentTransaction, Option<msgs::FundingSigned>) where L::Target: Logger {
2774                 let counterparty_keys = self.build_remote_transaction_keys();
2775                 let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number + 1, &counterparty_keys, false, false, logger).tx;
2776
2777                 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
2778                 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
2779                 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
2780                         &self.channel_id(), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
2781
2782                 match &self.holder_signer {
2783                         // TODO (arik): move match into calling method for Taproot
2784                         ChannelSignerType::Ecdsa(ecdsa) => {
2785                                 let funding_signed = ecdsa.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), Vec::new(), &self.secp_ctx)
2786                                         .map(|(signature, _)| msgs::FundingSigned {
2787                                                 channel_id: self.channel_id(),
2788                                                 signature,
2789                                                 #[cfg(taproot)]
2790                                                 partial_signature_with_nonce: None,
2791                                         })
2792                                         .ok();
2793
2794                                 if funding_signed.is_none() {
2795                                         #[cfg(not(async_signing))] {
2796                                                 panic!("Failed to get signature for funding_signed");
2797                                         }
2798                                         #[cfg(async_signing)] {
2799                                                 log_trace!(logger, "Counterparty commitment signature not available for funding_signed message; setting signer_pending_funding");
2800                                                 self.signer_pending_funding = true;
2801                                         }
2802                                 } else if self.signer_pending_funding {
2803                                         log_trace!(logger, "Counterparty commitment signature available for funding_signed message; clearing signer_pending_funding");
2804                                         self.signer_pending_funding = false;
2805                                 }
2806
2807                                 // We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
2808                                 (counterparty_initial_commitment_tx, funding_signed)
2809                         },
2810                         // TODO (taproot|arik)
2811                         #[cfg(taproot)]
2812                         _ => todo!()
2813                 }
2814         }
2815 }
2816
2817 // Internal utility functions for channels
2818
2819 /// Returns the value to use for `holder_max_htlc_value_in_flight_msat` as a percentage of the
2820 /// `channel_value_satoshis` in msat, set through
2821 /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]
2822 ///
2823 /// The effective percentage is lower bounded by 1% and upper bounded by 100%.
2824 ///
2825 /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]: crate::util::config::ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel
2826 fn get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis: u64, config: &ChannelHandshakeConfig) -> u64 {
2827         let configured_percent = if config.max_inbound_htlc_value_in_flight_percent_of_channel < 1 {
2828                 1
2829         } else if config.max_inbound_htlc_value_in_flight_percent_of_channel > 100 {
2830                 100
2831         } else {
2832                 config.max_inbound_htlc_value_in_flight_percent_of_channel as u64
2833         };
2834         channel_value_satoshis * 10 * configured_percent
2835 }
2836
2837 /// Returns a minimum channel reserve value the remote needs to maintain,
2838 /// required by us according to the configured or default
2839 /// [`ChannelHandshakeConfig::their_channel_reserve_proportional_millionths`]
2840 ///
2841 /// Guaranteed to return a value no larger than channel_value_satoshis
2842 ///
2843 /// This is used both for outbound and inbound channels and has lower bound
2844 /// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`.
2845 pub(crate) fn get_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64, config: &UserConfig) -> u64 {
2846         let calculated_reserve = channel_value_satoshis.saturating_mul(config.channel_handshake_config.their_channel_reserve_proportional_millionths as u64) / 1_000_000;
2847         cmp::min(channel_value_satoshis, cmp::max(calculated_reserve, MIN_THEIR_CHAN_RESERVE_SATOSHIS))
2848 }
2849
2850 /// This is for legacy reasons, present for forward-compatibility.
2851 /// LDK versions older than 0.0.104 don't know how read/handle values other than default
2852 /// from storage. Hence, we use this function to not persist default values of
2853 /// `holder_selected_channel_reserve_satoshis` for channels into storage.
2854 pub(crate) fn get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64) -> u64 {
2855         let (q, _) = channel_value_satoshis.overflowing_div(100);
2856         cmp::min(channel_value_satoshis, cmp::max(q, 1000))
2857 }
2858
2859 // Get the fee cost in SATS of a commitment tx with a given number of HTLC outputs.
2860 // Note that num_htlcs should not include dust HTLCs.
2861 #[inline]
2862 fn commit_tx_fee_sat(feerate_per_kw: u32, num_htlcs: usize, channel_type_features: &ChannelTypeFeatures) -> u64 {
2863         feerate_per_kw as u64 * (commitment_tx_base_weight(channel_type_features) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
2864 }
2865
2866 // Get the fee cost in MSATS of a commitment tx with a given number of HTLC outputs.
2867 // Note that num_htlcs should not include dust HTLCs.
2868 pub(crate) fn commit_tx_fee_msat(feerate_per_kw: u32, num_htlcs: usize, channel_type_features: &ChannelTypeFeatures) -> u64 {
2869         // Note that we need to divide before multiplying to round properly,
2870         // since the lowest denomination of bitcoin on-chain is the satoshi.
2871         (commitment_tx_base_weight(channel_type_features) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate_per_kw as u64 / 1000 * 1000
2872 }
2873
2874 // Holder designates channel data owned for the benefit of the user client.
2875 // Counterparty designates channel data owned by the another channel participant entity.
2876 pub(super) struct Channel<SP: Deref> where SP::Target: SignerProvider {
2877         pub context: ChannelContext<SP>,
2878 }
2879
2880 #[cfg(any(test, fuzzing))]
2881 struct CommitmentTxInfoCached {
2882         fee: u64,
2883         total_pending_htlcs: usize,
2884         next_holder_htlc_id: u64,
2885         next_counterparty_htlc_id: u64,
2886         feerate: u32,
2887 }
2888
2889 /// Contents of a wire message that fails an HTLC backwards. Useful for [`Channel::fail_htlc`] to
2890 /// fail with either [`msgs::UpdateFailMalformedHTLC`] or [`msgs::UpdateFailHTLC`] as needed.
2891 trait FailHTLCContents {
2892         type Message: FailHTLCMessageName;
2893         fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message;
2894         fn to_inbound_htlc_state(self) -> InboundHTLCState;
2895         fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK;
2896 }
2897 impl FailHTLCContents for msgs::OnionErrorPacket {
2898         type Message = msgs::UpdateFailHTLC;
2899         fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message {
2900                 msgs::UpdateFailHTLC { htlc_id, channel_id, reason: self }
2901         }
2902         fn to_inbound_htlc_state(self) -> InboundHTLCState {
2903                 InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(self))
2904         }
2905         fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK {
2906                 HTLCUpdateAwaitingACK::FailHTLC { htlc_id, err_packet: self }
2907         }
2908 }
2909 impl FailHTLCContents for ([u8; 32], u16) {
2910         type Message = msgs::UpdateFailMalformedHTLC;
2911         fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message {
2912                 msgs::UpdateFailMalformedHTLC {
2913                         htlc_id,
2914                         channel_id,
2915                         sha256_of_onion: self.0,
2916                         failure_code: self.1
2917                 }
2918         }
2919         fn to_inbound_htlc_state(self) -> InboundHTLCState {
2920                 InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed(self))
2921         }
2922         fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK {
2923                 HTLCUpdateAwaitingACK::FailMalformedHTLC {
2924                         htlc_id,
2925                         sha256_of_onion: self.0,
2926                         failure_code: self.1
2927                 }
2928         }
2929 }
2930
2931 trait FailHTLCMessageName {
2932         fn name() -> &'static str;
2933 }
2934 impl FailHTLCMessageName for msgs::UpdateFailHTLC {
2935         fn name() -> &'static str {
2936                 "update_fail_htlc"
2937         }
2938 }
2939 impl FailHTLCMessageName for msgs::UpdateFailMalformedHTLC {
2940         fn name() -> &'static str {
2941                 "update_fail_malformed_htlc"
2942         }
2943 }
2944
2945 impl<SP: Deref> Channel<SP> where
2946         SP::Target: SignerProvider,
2947         <SP::Target as SignerProvider>::EcdsaSigner: WriteableEcdsaChannelSigner
2948 {
2949         fn check_remote_fee<F: Deref, L: Deref>(
2950                 channel_type: &ChannelTypeFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,
2951                 feerate_per_kw: u32, cur_feerate_per_kw: Option<u32>, logger: &L
2952         ) -> Result<(), ChannelError> where F::Target: FeeEstimator, L::Target: Logger,
2953         {
2954                 let lower_limit_conf_target = if channel_type.supports_anchors_zero_fee_htlc_tx() {
2955                         ConfirmationTarget::MinAllowedAnchorChannelRemoteFee
2956                 } else {
2957                         ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee
2958                 };
2959                 let lower_limit = fee_estimator.bounded_sat_per_1000_weight(lower_limit_conf_target);
2960                 if feerate_per_kw < lower_limit {
2961                         if let Some(cur_feerate) = cur_feerate_per_kw {
2962                                 if feerate_per_kw > cur_feerate {
2963                                         log_warn!(logger,
2964                                                 "Accepting feerate that may prevent us from closing this channel because it's higher than what we have now. Had {} s/kW, now {} s/kW.",
2965                                                 cur_feerate, feerate_per_kw);
2966                                         return Ok(());
2967                                 }
2968                         }
2969                         return Err(ChannelError::Close(format!("Peer's feerate much too low. Actual: {}. Our expected lower limit: {}", feerate_per_kw, lower_limit)));
2970                 }
2971                 Ok(())
2972         }
2973
2974         #[inline]
2975         fn get_closing_scriptpubkey(&self) -> ScriptBuf {
2976                 // The shutdown scriptpubkey is set on channel opening when option_upfront_shutdown_script
2977                 // is signaled. Otherwise, it is set when sending a shutdown message. Calling this method
2978                 // outside of those situations will fail.
2979                 self.context.shutdown_scriptpubkey.clone().unwrap().into_inner()
2980         }
2981
2982         #[inline]
2983         fn get_closing_transaction_weight(&self, a_scriptpubkey: Option<&Script>, b_scriptpubkey: Option<&Script>) -> u64 {
2984                 let mut ret =
2985                 (4 +                                                   // version
2986                  1 +                                                   // input count
2987                  36 +                                                  // prevout
2988                  1 +                                                   // script length (0)
2989                  4 +                                                   // sequence
2990                  1 +                                                   // output count
2991                  4                                                     // lock time
2992                  )*4 +                                                 // * 4 for non-witness parts
2993                 2 +                                                    // witness marker and flag
2994                 1 +                                                    // witness element count
2995                 4 +                                                    // 4 element lengths (2 sigs, multisig dummy, and witness script)
2996                 self.context.get_funding_redeemscript().len() as u64 + // funding witness script
2997                 2*(1 + 71);                                            // two signatures + sighash type flags
2998                 if let Some(spk) = a_scriptpubkey {
2999                         ret += ((8+1) +                                    // output values and script length
3000                                 spk.len() as u64) * 4;                         // scriptpubkey and witness multiplier
3001                 }
3002                 if let Some(spk) = b_scriptpubkey {
3003                         ret += ((8+1) +                                    // output values and script length
3004                                 spk.len() as u64) * 4;                         // scriptpubkey and witness multiplier
3005                 }
3006                 ret
3007         }
3008
3009         #[inline]
3010         fn build_closing_transaction(&self, proposed_total_fee_satoshis: u64, skip_remote_output: bool) -> (ClosingTransaction, u64) {
3011                 assert!(self.context.pending_inbound_htlcs.is_empty());
3012                 assert!(self.context.pending_outbound_htlcs.is_empty());
3013                 assert!(self.context.pending_update_fee.is_none());
3014
3015                 let mut total_fee_satoshis = proposed_total_fee_satoshis;
3016                 let mut value_to_holder: i64 = (self.context.value_to_self_msat as i64) / 1000 - if self.context.is_outbound() { total_fee_satoshis as i64 } else { 0 };
3017                 let mut value_to_counterparty: i64 = ((self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat) as i64 / 1000) - if self.context.is_outbound() { 0 } else { total_fee_satoshis as i64 };
3018
3019                 if value_to_holder < 0 {
3020                         assert!(self.context.is_outbound());
3021                         total_fee_satoshis += (-value_to_holder) as u64;
3022                 } else if value_to_counterparty < 0 {
3023                         assert!(!self.context.is_outbound());
3024                         total_fee_satoshis += (-value_to_counterparty) as u64;
3025                 }
3026
3027                 if skip_remote_output || value_to_counterparty as u64 <= self.context.holder_dust_limit_satoshis {
3028                         value_to_counterparty = 0;
3029                 }
3030
3031                 if value_to_holder as u64 <= self.context.holder_dust_limit_satoshis {
3032                         value_to_holder = 0;
3033                 }
3034
3035                 assert!(self.context.shutdown_scriptpubkey.is_some());
3036                 let holder_shutdown_script = self.get_closing_scriptpubkey();
3037                 let counterparty_shutdown_script = self.context.counterparty_shutdown_scriptpubkey.clone().unwrap();
3038                 let funding_outpoint = self.funding_outpoint().into_bitcoin_outpoint();
3039
3040                 let closing_transaction = ClosingTransaction::new(value_to_holder as u64, value_to_counterparty as u64, holder_shutdown_script, counterparty_shutdown_script, funding_outpoint);
3041                 (closing_transaction, total_fee_satoshis)
3042         }
3043
3044         fn funding_outpoint(&self) -> OutPoint {
3045                 self.context.channel_transaction_parameters.funding_outpoint.unwrap()
3046         }
3047
3048         /// Claims an HTLC while we're disconnected from a peer, dropping the [`ChannelMonitorUpdate`]
3049         /// entirely.
3050         ///
3051         /// The [`ChannelMonitor`] for this channel MUST be updated out-of-band with the preimage
3052         /// provided (i.e. without calling [`crate::chain::Watch::update_channel`]).
3053         ///
3054         /// The HTLC claim will end up in the holding cell (because the caller must ensure the peer is
3055         /// disconnected).
3056         pub fn claim_htlc_while_disconnected_dropping_mon_update<L: Deref>
3057                 (&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L)
3058         where L::Target: Logger {
3059                 // Assert that we'll add the HTLC claim to the holding cell in `get_update_fulfill_htlc`
3060                 // (see equivalent if condition there).
3061                 assert!(!self.context.channel_state.can_generate_new_commitment());
3062                 let mon_update_id = self.context.latest_monitor_update_id; // Forget the ChannelMonitor update
3063                 let fulfill_resp = self.get_update_fulfill_htlc(htlc_id_arg, payment_preimage_arg, logger);
3064                 self.context.latest_monitor_update_id = mon_update_id;
3065                 if let UpdateFulfillFetch::NewClaim { msg, .. } = fulfill_resp {
3066                         assert!(msg.is_none()); // The HTLC must have ended up in the holding cell.
3067                 }
3068         }
3069
3070         fn get_update_fulfill_htlc<L: Deref>(&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L) -> UpdateFulfillFetch where L::Target: Logger {
3071                 // Either ChannelReady got set (which means it won't be unset) or there is no way any
3072                 // caller thought we could have something claimed (cause we wouldn't have accepted in an
3073                 // incoming HTLC anyway). If we got to ShutdownComplete, callers aren't allowed to call us,
3074                 // either.
3075                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3076                         panic!("Was asked to fulfill an HTLC when channel was not in an operational state");
3077                 }
3078
3079                 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
3080                 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
3081                 // these, but for now we just have to treat them as normal.
3082
3083                 let mut pending_idx = core::usize::MAX;
3084                 let mut htlc_value_msat = 0;
3085                 for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
3086                         if htlc.htlc_id == htlc_id_arg {
3087                                 debug_assert_eq!(htlc.payment_hash, PaymentHash(Sha256::hash(&payment_preimage_arg.0[..]).to_byte_array()));
3088                                 log_debug!(logger, "Claiming inbound HTLC id {} with payment hash {} with preimage {}",
3089                                         htlc.htlc_id, htlc.payment_hash, payment_preimage_arg);
3090                                 match htlc.state {
3091                                         InboundHTLCState::Committed => {},
3092                                         InboundHTLCState::LocalRemoved(ref reason) => {
3093                                                 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
3094                                                 } else {
3095                                                         log_warn!(logger, "Have preimage and want to fulfill HTLC with payment hash {} we already failed against channel {}", &htlc.payment_hash, &self.context.channel_id());
3096                                                         debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
3097                                                 }
3098                                                 return UpdateFulfillFetch::DuplicateClaim {};
3099                                         },
3100                                         _ => {
3101                                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
3102                                                 // Don't return in release mode here so that we can update channel_monitor
3103                                         }
3104                                 }
3105                                 pending_idx = idx;
3106                                 htlc_value_msat = htlc.amount_msat;
3107                                 break;
3108                         }
3109                 }
3110                 if pending_idx == core::usize::MAX {
3111                         #[cfg(any(test, fuzzing))]
3112                         // If we failed to find an HTLC to fulfill, make sure it was previously fulfilled and
3113                         // this is simply a duplicate claim, not previously failed and we lost funds.
3114                         debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
3115                         return UpdateFulfillFetch::DuplicateClaim {};
3116                 }
3117
3118                 // Now update local state:
3119                 //
3120                 // We have to put the payment_preimage in the channel_monitor right away here to ensure we
3121                 // can claim it even if the channel hits the chain before we see their next commitment.
3122                 self.context.latest_monitor_update_id += 1;
3123                 let monitor_update = ChannelMonitorUpdate {
3124                         update_id: self.context.latest_monitor_update_id,
3125                         counterparty_node_id: Some(self.context.counterparty_node_id),
3126                         updates: vec![ChannelMonitorUpdateStep::PaymentPreimage {
3127                                 payment_preimage: payment_preimage_arg.clone(),
3128                         }],
3129                         channel_id: Some(self.context.channel_id()),
3130                 };
3131
3132                 if !self.context.channel_state.can_generate_new_commitment() {
3133                         // Note that this condition is the same as the assertion in
3134                         // `claim_htlc_while_disconnected_dropping_mon_update` and must match exactly -
3135                         // `claim_htlc_while_disconnected_dropping_mon_update` would not work correctly if we
3136                         // do not not get into this branch.
3137                         for pending_update in self.context.holding_cell_htlc_updates.iter() {
3138                                 match pending_update {
3139                                         &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
3140                                                 if htlc_id_arg == htlc_id {
3141                                                         // Make sure we don't leave latest_monitor_update_id incremented here:
3142                                                         self.context.latest_monitor_update_id -= 1;
3143                                                         #[cfg(any(test, fuzzing))]
3144                                                         debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
3145                                                         return UpdateFulfillFetch::DuplicateClaim {};
3146                                                 }
3147                                         },
3148                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } |
3149                                                 &HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } =>
3150                                         {
3151                                                 if htlc_id_arg == htlc_id {
3152                                                         log_warn!(logger, "Have preimage and want to fulfill HTLC with pending failure against channel {}", &self.context.channel_id());
3153                                                         // TODO: We may actually be able to switch to a fulfill here, though its
3154                                                         // rare enough it may not be worth the complexity burden.
3155                                                         debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
3156                                                         return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
3157                                                 }
3158                                         },
3159                                         _ => {}
3160                                 }
3161                         }
3162                         log_trace!(logger, "Adding HTLC claim to holding_cell in channel {}! Current state: {}", &self.context.channel_id(), self.context.channel_state.to_u32());
3163                         self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
3164                                 payment_preimage: payment_preimage_arg, htlc_id: htlc_id_arg,
3165                         });
3166                         #[cfg(any(test, fuzzing))]
3167                         self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
3168                         return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
3169                 }
3170                 #[cfg(any(test, fuzzing))]
3171                 self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
3172
3173                 {
3174                         let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
3175                         if let InboundHTLCState::Committed = htlc.state {
3176                         } else {
3177                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
3178                                 return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
3179                         }
3180                         log_trace!(logger, "Upgrading HTLC {} to LocalRemoved with a Fulfill in channel {}!", &htlc.payment_hash, &self.context.channel_id);
3181                         htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(payment_preimage_arg.clone()));
3182                 }
3183
3184                 UpdateFulfillFetch::NewClaim {
3185                         monitor_update,
3186                         htlc_value_msat,
3187                         msg: Some(msgs::UpdateFulfillHTLC {
3188                                 channel_id: self.context.channel_id(),
3189                                 htlc_id: htlc_id_arg,
3190                                 payment_preimage: payment_preimage_arg,
3191                         }),
3192                 }
3193         }
3194
3195         pub fn get_update_fulfill_htlc_and_commit<L: Deref>(&mut self, htlc_id: u64, payment_preimage: PaymentPreimage, logger: &L) -> UpdateFulfillCommitFetch where L::Target: Logger {
3196                 let release_cs_monitor = self.context.blocked_monitor_updates.is_empty();
3197                 match self.get_update_fulfill_htlc(htlc_id, payment_preimage, logger) {
3198                         UpdateFulfillFetch::NewClaim { mut monitor_update, htlc_value_msat, msg } => {
3199                                 // Even if we aren't supposed to let new monitor updates with commitment state
3200                                 // updates run, we still need to push the preimage ChannelMonitorUpdateStep no
3201                                 // matter what. Sadly, to push a new monitor update which flies before others
3202                                 // already queued, we have to insert it into the pending queue and update the
3203                                 // update_ids of all the following monitors.
3204                                 if release_cs_monitor && msg.is_some() {
3205                                         let mut additional_update = self.build_commitment_no_status_check(logger);
3206                                         // build_commitment_no_status_check may bump latest_monitor_id but we want them
3207                                         // to be strictly increasing by one, so decrement it here.
3208                                         self.context.latest_monitor_update_id = monitor_update.update_id;
3209                                         monitor_update.updates.append(&mut additional_update.updates);
3210                                 } else {
3211                                         let new_mon_id = self.context.blocked_monitor_updates.get(0)
3212                                                 .map(|upd| upd.update.update_id).unwrap_or(monitor_update.update_id);
3213                                         monitor_update.update_id = new_mon_id;
3214                                         for held_update in self.context.blocked_monitor_updates.iter_mut() {
3215                                                 held_update.update.update_id += 1;
3216                                         }
3217                                         if msg.is_some() {
3218                                                 debug_assert!(false, "If there is a pending blocked monitor we should have MonitorUpdateInProgress set");
3219                                                 let update = self.build_commitment_no_status_check(logger);
3220                                                 self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
3221                                                         update,
3222                                                 });
3223                                         }
3224                                 }
3225
3226                                 self.monitor_updating_paused(false, msg.is_some(), false, Vec::new(), Vec::new(), Vec::new());
3227                                 UpdateFulfillCommitFetch::NewClaim { monitor_update, htlc_value_msat, }
3228                         },
3229                         UpdateFulfillFetch::DuplicateClaim {} => UpdateFulfillCommitFetch::DuplicateClaim {},
3230                 }
3231         }
3232
3233         /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
3234         /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
3235         /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
3236         /// before we fail backwards.
3237         ///
3238         /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
3239         /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
3240         /// [`ChannelError::Ignore`].
3241         pub fn queue_fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, logger: &L)
3242         -> Result<(), ChannelError> where L::Target: Logger {
3243                 self.fail_htlc(htlc_id_arg, err_packet, true, logger)
3244                         .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
3245         }
3246
3247         /// Used for failing back with [`msgs::UpdateFailMalformedHTLC`]. For now, this is used when we
3248         /// want to fail blinded HTLCs where we are not the intro node.
3249         ///
3250         /// See [`Self::queue_fail_htlc`] for more info.
3251         pub fn queue_fail_malformed_htlc<L: Deref>(
3252                 &mut self, htlc_id_arg: u64, failure_code: u16, sha256_of_onion: [u8; 32], logger: &L
3253         ) -> Result<(), ChannelError> where L::Target: Logger {
3254                 self.fail_htlc(htlc_id_arg, (sha256_of_onion, failure_code), true, logger)
3255                         .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
3256         }
3257
3258         /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
3259         /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
3260         /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
3261         /// before we fail backwards.
3262         ///
3263         /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
3264         /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
3265         /// [`ChannelError::Ignore`].
3266         fn fail_htlc<L: Deref, E: FailHTLCContents + Clone>(
3267                 &mut self, htlc_id_arg: u64, err_contents: E, mut force_holding_cell: bool,
3268                 logger: &L
3269         ) -> Result<Option<E::Message>, ChannelError> where L::Target: Logger {
3270                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3271                         panic!("Was asked to fail an HTLC when channel was not in an operational state");
3272                 }
3273
3274                 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
3275                 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
3276                 // these, but for now we just have to treat them as normal.
3277
3278                 let mut pending_idx = core::usize::MAX;
3279                 for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
3280                         if htlc.htlc_id == htlc_id_arg {
3281                                 match htlc.state {
3282                                         InboundHTLCState::Committed => {},
3283                                         InboundHTLCState::LocalRemoved(ref reason) => {
3284                                                 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
3285                                                 } else {
3286                                                         debug_assert!(false, "Tried to fail an HTLC that was already failed");
3287                                                 }
3288                                                 return Ok(None);
3289                                         },
3290                                         _ => {
3291                                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
3292                                                 return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc.htlc_id)));
3293                                         }
3294                                 }
3295                                 pending_idx = idx;
3296                         }
3297                 }
3298                 if pending_idx == core::usize::MAX {
3299                         #[cfg(any(test, fuzzing))]
3300                         // If we failed to find an HTLC to fail, make sure it was previously fulfilled and this
3301                         // is simply a duplicate fail, not previously failed and we failed-back too early.
3302                         debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
3303                         return Ok(None);
3304                 }
3305
3306                 if !self.context.channel_state.can_generate_new_commitment() {
3307                         debug_assert!(force_holding_cell, "!force_holding_cell is only called when emptying the holding cell, so we shouldn't end up back in it!");
3308                         force_holding_cell = true;
3309                 }
3310
3311                 // Now update local state:
3312                 if force_holding_cell {
3313                         for pending_update in self.context.holding_cell_htlc_updates.iter() {
3314                                 match pending_update {
3315                                         &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
3316                                                 if htlc_id_arg == htlc_id {
3317                                                         #[cfg(any(test, fuzzing))]
3318                                                         debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
3319                                                         return Ok(None);
3320                                                 }
3321                                         },
3322                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } |
3323                                                 &HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } =>
3324                                         {
3325                                                 if htlc_id_arg == htlc_id {
3326                                                         debug_assert!(false, "Tried to fail an HTLC that was already failed");
3327                                                         return Err(ChannelError::Ignore("Unable to find a pending HTLC which matched the given HTLC ID".to_owned()));
3328                                                 }
3329                                         },
3330                                         _ => {}
3331                                 }
3332                         }
3333                         log_trace!(logger, "Placing failure for HTLC ID {} in holding cell in channel {}.", htlc_id_arg, &self.context.channel_id());
3334                         self.context.holding_cell_htlc_updates.push(err_contents.to_htlc_update_awaiting_ack(htlc_id_arg));
3335                         return Ok(None);
3336                 }
3337
3338                 log_trace!(logger, "Failing HTLC ID {} back with {} message in channel {}.", htlc_id_arg,
3339                         E::Message::name(), &self.context.channel_id());
3340                 {
3341                         let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
3342                         htlc.state = err_contents.clone().to_inbound_htlc_state();
3343                 }
3344
3345                 Ok(Some(err_contents.to_message(htlc_id_arg, self.context.channel_id())))
3346         }
3347
3348         // Message handlers:
3349         /// Updates the state of the channel to indicate that all channels in the batch have received
3350         /// funding_signed and persisted their monitors.
3351         /// The funding transaction is consequently allowed to be broadcast, and the channel can be
3352         /// treated as a non-batch channel going forward.
3353         pub fn set_batch_ready(&mut self) {
3354                 self.context.is_batch_funding = None;
3355                 self.context.channel_state.clear_waiting_for_batch();
3356         }
3357
3358         /// Unsets the existing funding information.
3359         ///
3360         /// This must only be used if the channel has not yet completed funding and has not been used.
3361         ///
3362         /// Further, the channel must be immediately shut down after this with a call to
3363         /// [`ChannelContext::force_shutdown`].
3364         pub fn unset_funding_info(&mut self, temporary_channel_id: ChannelId) {
3365                 debug_assert!(matches!(
3366                         self.context.channel_state, ChannelState::AwaitingChannelReady(_)
3367                 ));
3368                 self.context.channel_transaction_parameters.funding_outpoint = None;
3369                 self.context.channel_id = temporary_channel_id;
3370         }
3371
3372         /// Handles a channel_ready message from our peer. If we've already sent our channel_ready
3373         /// and the channel is now usable (and public), this may generate an announcement_signatures to
3374         /// reply with.
3375         pub fn channel_ready<NS: Deref, L: Deref>(
3376                 &mut self, msg: &msgs::ChannelReady, node_signer: &NS, chain_hash: ChainHash,
3377                 user_config: &UserConfig, best_block: &BestBlock, logger: &L
3378         ) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError>
3379         where
3380                 NS::Target: NodeSigner,
3381                 L::Target: Logger
3382         {
3383                 if self.context.channel_state.is_peer_disconnected() {
3384                         self.context.workaround_lnd_bug_4006 = Some(msg.clone());
3385                         return Err(ChannelError::Ignore("Peer sent channel_ready when we needed a channel_reestablish. The peer is likely lnd, see https://github.com/lightningnetwork/lnd/issues/4006".to_owned()));
3386                 }
3387
3388                 if let Some(scid_alias) = msg.short_channel_id_alias {
3389                         if Some(scid_alias) != self.context.short_channel_id {
3390                                 // The scid alias provided can be used to route payments *from* our counterparty,
3391                                 // i.e. can be used for inbound payments and provided in invoices, but is not used
3392                                 // when routing outbound payments.
3393                                 self.context.latest_inbound_scid_alias = Some(scid_alias);
3394                         }
3395                 }
3396
3397                 // Our channel_ready shouldn't have been sent if we are waiting for other channels in the
3398                 // batch, but we can receive channel_ready messages.
3399                 let mut check_reconnection = false;
3400                 match &self.context.channel_state {
3401                         ChannelState::AwaitingChannelReady(flags) => {
3402                                 let flags = flags.clone().clear(FundedStateFlags::ALL.into());
3403                                 debug_assert!(!flags.is_set(AwaitingChannelReadyFlags::OUR_CHANNEL_READY) || !flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));
3404                                 if flags.clone().clear(AwaitingChannelReadyFlags::WAITING_FOR_BATCH) == AwaitingChannelReadyFlags::THEIR_CHANNEL_READY {
3405                                         // If we reconnected before sending our `channel_ready` they may still resend theirs.
3406                                         check_reconnection = true;
3407                                 } else if flags.clone().clear(AwaitingChannelReadyFlags::WAITING_FOR_BATCH).is_empty() {
3408                                         self.context.channel_state.set_their_channel_ready();
3409                                 } else if flags == AwaitingChannelReadyFlags::OUR_CHANNEL_READY {
3410                                         self.context.channel_state = ChannelState::ChannelReady(self.context.channel_state.with_funded_state_flags_mask().into());
3411                                         self.context.update_time_counter += 1;
3412                                 } else {
3413                                         // We're in `WAITING_FOR_BATCH`, so we should wait until we're ready.
3414                                         debug_assert!(flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));
3415                                 }
3416                         }
3417                         // If we reconnected before sending our `channel_ready` they may still resend theirs.
3418                         ChannelState::ChannelReady(_) => check_reconnection = true,
3419                         _ => return Err(ChannelError::Close("Peer sent a channel_ready at a strange time".to_owned())),
3420                 }
3421                 if check_reconnection {
3422                         // They probably disconnected/reconnected and re-sent the channel_ready, which is
3423                         // required, or they're sending a fresh SCID alias.
3424                         let expected_point =
3425                                 if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
3426                                         // If they haven't ever sent an updated point, the point they send should match
3427                                         // the current one.
3428                                         self.context.counterparty_cur_commitment_point
3429                                 } else if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
3430                                         // If we've advanced the commitment number once, the second commitment point is
3431                                         // at `counterparty_prev_commitment_point`, which is not yet revoked.
3432                                         debug_assert!(self.context.counterparty_prev_commitment_point.is_some());
3433                                         self.context.counterparty_prev_commitment_point
3434                                 } else {
3435                                         // If they have sent updated points, channel_ready is always supposed to match
3436                                         // their "first" point, which we re-derive here.
3437                                         Some(PublicKey::from_secret_key(&self.context.secp_ctx, &SecretKey::from_slice(
3438                                                         &self.context.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
3439                                                 ).expect("We already advanced, so previous secret keys should have been validated already")))
3440                                 };
3441                         if expected_point != Some(msg.next_per_commitment_point) {
3442                                 return Err(ChannelError::Close("Peer sent a reconnect channel_ready with a different point".to_owned()));
3443                         }
3444                         return Ok(None);
3445                 }
3446
3447                 self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
3448                 self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
3449
3450                 log_info!(logger, "Received channel_ready from peer for channel {}", &self.context.channel_id());
3451
3452                 Ok(self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block.height(), logger))
3453         }
3454
3455         pub fn update_add_htlc<F, FE: Deref, L: Deref>(
3456                 &mut self, msg: &msgs::UpdateAddHTLC, mut pending_forward_status: PendingHTLCStatus,
3457                 create_pending_htlc_status: F, fee_estimator: &LowerBoundedFeeEstimator<FE>, logger: &L
3458         ) -> Result<(), ChannelError>
3459         where F: for<'a> Fn(&'a Self, PendingHTLCStatus, u16) -> PendingHTLCStatus,
3460                 FE::Target: FeeEstimator, L::Target: Logger,
3461         {
3462                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3463                         return Err(ChannelError::Close("Got add HTLC message when channel was not in an operational state".to_owned()));
3464                 }
3465                 // We can't accept HTLCs sent after we've sent a shutdown.
3466                 if self.context.channel_state.is_local_shutdown_sent() {
3467                         pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x4000|8);
3468                 }
3469                 // If the remote has sent a shutdown prior to adding this HTLC, then they are in violation of the spec.
3470                 if self.context.channel_state.is_remote_shutdown_sent() {
3471                         return Err(ChannelError::Close("Got add HTLC message when channel was not in an operational state".to_owned()));
3472                 }
3473                 if self.context.channel_state.is_peer_disconnected() {
3474                         return Err(ChannelError::Close("Peer sent update_add_htlc when we needed a channel_reestablish".to_owned()));
3475                 }
3476                 if msg.amount_msat > self.context.channel_value_satoshis * 1000 {
3477                         return Err(ChannelError::Close("Remote side tried to send more than the total value of the channel".to_owned()));
3478                 }
3479                 if msg.amount_msat == 0 {
3480                         return Err(ChannelError::Close("Remote side tried to send a 0-msat HTLC".to_owned()));
3481                 }
3482                 if msg.amount_msat < self.context.holder_htlc_minimum_msat {
3483                         return Err(ChannelError::Close(format!("Remote side tried to send less than our minimum HTLC value. Lower limit: ({}). Actual: ({})", self.context.holder_htlc_minimum_msat, msg.amount_msat)));
3484                 }
3485
3486                 let inbound_stats = self.context.get_inbound_pending_htlc_stats(None);
3487                 let outbound_stats = self.context.get_outbound_pending_htlc_stats(None);
3488                 if inbound_stats.pending_htlcs + 1 > self.context.holder_max_accepted_htlcs as u32 {
3489                         return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", self.context.holder_max_accepted_htlcs)));
3490                 }
3491                 if inbound_stats.pending_htlcs_value_msat + msg.amount_msat > self.context.holder_max_htlc_value_in_flight_msat {
3492                         return Err(ChannelError::Close(format!("Remote HTLC add would put them over our max HTLC value ({})", self.context.holder_max_htlc_value_in_flight_msat)));
3493                 }
3494
3495                 // Check holder_selected_channel_reserve_satoshis (we're getting paid, so they have to at least meet
3496                 // the reserve_satoshis we told them to always have as direct payment so that they lose
3497                 // something if we punish them for broadcasting an old state).
3498                 // Note that we don't really care about having a small/no to_remote output in our local
3499                 // commitment transactions, as the purpose of the channel reserve is to ensure we can
3500                 // punish *them* if they misbehave, so we discount any outbound HTLCs which will not be
3501                 // present in the next commitment transaction we send them (at least for fulfilled ones,
3502                 // failed ones won't modify value_to_self).
3503                 // Note that we will send HTLCs which another instance of rust-lightning would think
3504                 // violate the reserve value if we do not do this (as we forget inbound HTLCs from the
3505                 // Channel state once they will not be present in the next received commitment
3506                 // transaction).
3507                 let mut removed_outbound_total_msat = 0;
3508                 for ref htlc in self.context.pending_outbound_htlcs.iter() {
3509                         if let OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_)) = htlc.state {
3510                                 removed_outbound_total_msat += htlc.amount_msat;
3511                         } else if let OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) = htlc.state {
3512                                 removed_outbound_total_msat += htlc.amount_msat;
3513                         }
3514                 }
3515
3516                 let max_dust_htlc_exposure_msat = self.context.get_max_dust_htlc_exposure_msat(fee_estimator);
3517                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if self.context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3518                         (0, 0)
3519                 } else {
3520                         let dust_buffer_feerate = self.context.get_dust_buffer_feerate(None) as u64;
3521                         (dust_buffer_feerate * htlc_timeout_tx_weight(self.context.get_channel_type()) / 1000,
3522                                 dust_buffer_feerate * htlc_success_tx_weight(self.context.get_channel_type()) / 1000)
3523                 };
3524                 let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.context.counterparty_dust_limit_satoshis;
3525                 if msg.amount_msat / 1000 < exposure_dust_limit_timeout_sats {
3526                         let on_counterparty_tx_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat + msg.amount_msat;
3527                         if on_counterparty_tx_dust_htlc_exposure_msat > max_dust_htlc_exposure_msat {
3528                                 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on counterparty commitment tx",
3529                                         on_counterparty_tx_dust_htlc_exposure_msat, max_dust_htlc_exposure_msat);
3530                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
3531                         }
3532                 }
3533
3534                 let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.context.holder_dust_limit_satoshis;
3535                 if msg.amount_msat / 1000 < exposure_dust_limit_success_sats {
3536                         let on_holder_tx_dust_htlc_exposure_msat = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat + msg.amount_msat;
3537                         if on_holder_tx_dust_htlc_exposure_msat > max_dust_htlc_exposure_msat {
3538                                 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on holder commitment tx",
3539                                         on_holder_tx_dust_htlc_exposure_msat, max_dust_htlc_exposure_msat);
3540                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
3541                         }
3542                 }
3543
3544                 let pending_value_to_self_msat =
3545                         self.context.value_to_self_msat + inbound_stats.pending_htlcs_value_msat - removed_outbound_total_msat;
3546                 let pending_remote_value_msat =
3547                         self.context.channel_value_satoshis * 1000 - pending_value_to_self_msat;
3548                 if pending_remote_value_msat < msg.amount_msat {
3549                         return Err(ChannelError::Close("Remote HTLC add would overdraw remaining funds".to_owned()));
3550                 }
3551
3552                 // Check that the remote can afford to pay for this HTLC on-chain at the current
3553                 // feerate_per_kw, while maintaining their channel reserve (as required by the spec).
3554                 {
3555                         let remote_commit_tx_fee_msat = if self.context.is_outbound() { 0 } else {
3556                                 let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
3557                                 self.context.next_remote_commit_tx_fee_msat(htlc_candidate, None) // Don't include the extra fee spike buffer HTLC in calculations
3558                         };
3559                         let anchor_outputs_value_msat = if !self.context.is_outbound() && self.context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3560                                 ANCHOR_OUTPUT_VALUE_SATOSHI * 2 * 1000
3561                         } else {
3562                                 0
3563                         };
3564                         if pending_remote_value_msat.saturating_sub(msg.amount_msat).saturating_sub(anchor_outputs_value_msat) < remote_commit_tx_fee_msat {
3565                                 return Err(ChannelError::Close("Remote HTLC add would not leave enough to pay for fees".to_owned()));
3566                         };
3567                         if pending_remote_value_msat.saturating_sub(msg.amount_msat).saturating_sub(remote_commit_tx_fee_msat).saturating_sub(anchor_outputs_value_msat) < self.context.holder_selected_channel_reserve_satoshis * 1000 {
3568                                 return Err(ChannelError::Close("Remote HTLC add would put them under remote reserve value".to_owned()));
3569                         }
3570                 }
3571
3572                 let anchor_outputs_value_msat = if self.context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3573                         ANCHOR_OUTPUT_VALUE_SATOSHI * 2 * 1000
3574                 } else {
3575                         0
3576                 };
3577                 if !self.context.is_outbound() {
3578                         // `Some(())` is for the fee spike buffer we keep for the remote. This deviates from
3579                         // the spec because the fee spike buffer requirement doesn't exist on the receiver's
3580                         // side, only on the sender's. Note that with anchor outputs we are no longer as
3581                         // sensitive to fee spikes, so we need to account for them.
3582                         let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
3583                         let mut remote_fee_cost_incl_stuck_buffer_msat = self.context.next_remote_commit_tx_fee_msat(htlc_candidate, Some(()));
3584                         if !self.context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
3585                                 remote_fee_cost_incl_stuck_buffer_msat *= FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
3586                         }
3587                         if pending_remote_value_msat.saturating_sub(msg.amount_msat).saturating_sub(self.context.holder_selected_channel_reserve_satoshis * 1000).saturating_sub(anchor_outputs_value_msat) < remote_fee_cost_incl_stuck_buffer_msat {
3588                                 // Note that if the pending_forward_status is not updated here, then it's because we're already failing
3589                                 // the HTLC, i.e. its status is already set to failing.
3590                                 log_info!(logger, "Attempting to fail HTLC due to fee spike buffer violation in channel {}. Rebalancing is required.", &self.context.channel_id());
3591                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
3592                         }
3593                 } else {
3594                         // Check that they won't violate our local required channel reserve by adding this HTLC.
3595                         let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
3596                         let local_commit_tx_fee_msat = self.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
3597                         if self.context.value_to_self_msat < self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 + local_commit_tx_fee_msat + anchor_outputs_value_msat {
3598                                 return Err(ChannelError::Close("Cannot accept HTLC that would put our balance under counterparty-announced channel reserve value".to_owned()));
3599                         }
3600                 }
3601                 if self.context.next_counterparty_htlc_id != msg.htlc_id {
3602                         return Err(ChannelError::Close(format!("Remote skipped HTLC ID (skipped ID: {})", self.context.next_counterparty_htlc_id)));
3603                 }
3604                 if msg.cltv_expiry >= 500000000 {
3605                         return Err(ChannelError::Close("Remote provided CLTV expiry in seconds instead of block height".to_owned()));
3606                 }
3607
3608                 if self.context.channel_state.is_local_shutdown_sent() {
3609                         if let PendingHTLCStatus::Forward(_) = pending_forward_status {
3610                                 panic!("ChannelManager shouldn't be trying to add a forwardable HTLC after we've started closing");
3611                         }
3612                 }
3613
3614                 // Now update local state:
3615                 self.context.next_counterparty_htlc_id += 1;
3616                 self.context.pending_inbound_htlcs.push(InboundHTLCOutput {
3617                         htlc_id: msg.htlc_id,
3618                         amount_msat: msg.amount_msat,
3619                         payment_hash: msg.payment_hash,
3620                         cltv_expiry: msg.cltv_expiry,
3621                         state: InboundHTLCState::RemoteAnnounced(pending_forward_status),
3622                 });
3623                 Ok(())
3624         }
3625
3626         /// Marks an outbound HTLC which we have received update_fail/fulfill/malformed
3627         #[inline]
3628         fn mark_outbound_htlc_removed(&mut self, htlc_id: u64, check_preimage: Option<PaymentPreimage>, fail_reason: Option<HTLCFailReason>) -> Result<&OutboundHTLCOutput, ChannelError> {
3629                 assert!(!(check_preimage.is_some() && fail_reason.is_some()), "cannot fail while we have a preimage");
3630                 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
3631                         if htlc.htlc_id == htlc_id {
3632                                 let outcome = match check_preimage {
3633                                         None => fail_reason.into(),
3634                                         Some(payment_preimage) => {
3635                                                 let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).to_byte_array());
3636                                                 if payment_hash != htlc.payment_hash {
3637                                                         return Err(ChannelError::Close(format!("Remote tried to fulfill HTLC ({}) with an incorrect preimage", htlc_id)));
3638                                                 }
3639                                                 OutboundHTLCOutcome::Success(Some(payment_preimage))
3640                                         }
3641                                 };
3642                                 match htlc.state {
3643                                         OutboundHTLCState::LocalAnnounced(_) =>
3644                                                 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) before it had been committed", htlc_id))),
3645                                         OutboundHTLCState::Committed => {
3646                                                 htlc.state = OutboundHTLCState::RemoteRemoved(outcome);
3647                                         },
3648                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) | OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) | OutboundHTLCState::RemoteRemoved(_) =>
3649                                                 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) that they'd already fulfilled/failed", htlc_id))),
3650                                 }
3651                                 return Ok(htlc);
3652                         }
3653                 }
3654                 Err(ChannelError::Close("Remote tried to fulfill/fail an HTLC we couldn't find".to_owned()))
3655         }
3656
3657         pub fn update_fulfill_htlc(&mut self, msg: &msgs::UpdateFulfillHTLC) -> Result<(HTLCSource, u64, Option<u64>), ChannelError> {
3658                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3659                         return Err(ChannelError::Close("Got fulfill HTLC message when channel was not in an operational state".to_owned()));
3660                 }
3661                 if self.context.channel_state.is_peer_disconnected() {
3662                         return Err(ChannelError::Close("Peer sent update_fulfill_htlc when we needed a channel_reestablish".to_owned()));
3663                 }
3664
3665                 self.mark_outbound_htlc_removed(msg.htlc_id, Some(msg.payment_preimage), None).map(|htlc| (htlc.source.clone(), htlc.amount_msat, htlc.skimmed_fee_msat))
3666         }
3667
3668         pub fn update_fail_htlc(&mut self, msg: &msgs::UpdateFailHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
3669                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3670                         return Err(ChannelError::Close("Got fail HTLC message when channel was not in an operational state".to_owned()));
3671                 }
3672                 if self.context.channel_state.is_peer_disconnected() {
3673                         return Err(ChannelError::Close("Peer sent update_fail_htlc when we needed a channel_reestablish".to_owned()));
3674                 }
3675
3676                 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
3677                 Ok(())
3678         }
3679
3680         pub fn update_fail_malformed_htlc(&mut self, msg: &msgs::UpdateFailMalformedHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
3681                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3682                         return Err(ChannelError::Close("Got fail malformed HTLC message when channel was not in an operational state".to_owned()));
3683                 }
3684                 if self.context.channel_state.is_peer_disconnected() {
3685                         return Err(ChannelError::Close("Peer sent update_fail_malformed_htlc when we needed a channel_reestablish".to_owned()));
3686                 }
3687
3688                 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
3689                 Ok(())
3690         }
3691
3692         pub fn commitment_signed<L: Deref>(&mut self, msg: &msgs::CommitmentSigned, logger: &L) -> Result<Option<ChannelMonitorUpdate>, ChannelError>
3693                 where L::Target: Logger
3694         {
3695                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
3696                         return Err(ChannelError::Close("Got commitment signed message when channel was not in an operational state".to_owned()));
3697                 }
3698                 if self.context.channel_state.is_peer_disconnected() {
3699                         return Err(ChannelError::Close("Peer sent commitment_signed when we needed a channel_reestablish".to_owned()));
3700                 }
3701                 if self.context.channel_state.is_both_sides_shutdown() && self.context.last_sent_closing_fee.is_some() {
3702                         return Err(ChannelError::Close("Peer sent commitment_signed after we'd started exchanging closing_signeds".to_owned()));
3703                 }
3704
3705                 let funding_script = self.context.get_funding_redeemscript();
3706
3707                 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
3708
3709                 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger);
3710                 let commitment_txid = {
3711                         let trusted_tx = commitment_stats.tx.trust();
3712                         let bitcoin_tx = trusted_tx.built_transaction();
3713                         let sighash = bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
3714
3715                         log_trace!(logger, "Checking commitment tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}",
3716                                 log_bytes!(msg.signature.serialize_compact()[..]),
3717                                 log_bytes!(self.context.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&bitcoin_tx.transaction),
3718                                 log_bytes!(sighash[..]), encode::serialize_hex(&funding_script), &self.context.channel_id());
3719                         if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.counterparty_funding_pubkey()) {
3720                                 return Err(ChannelError::Close("Invalid commitment tx signature from peer".to_owned()));
3721                         }
3722                         bitcoin_tx.txid
3723                 };
3724                 let mut htlcs_cloned: Vec<_> = commitment_stats.htlcs_included.iter().map(|htlc| (htlc.0.clone(), htlc.1.map(|h| h.clone()))).collect();
3725
3726                 // If our counterparty updated the channel fee in this commitment transaction, check that
3727                 // they can actually afford the new fee now.
3728                 let update_fee = if let Some((_, update_state)) = self.context.pending_update_fee {
3729                         update_state == FeeUpdateState::RemoteAnnounced
3730                 } else { false };
3731                 if update_fee {
3732                         debug_assert!(!self.context.is_outbound());
3733                         let counterparty_reserve_we_require_msat = self.context.holder_selected_channel_reserve_satoshis * 1000;
3734                         if commitment_stats.remote_balance_msat < commitment_stats.total_fee_sat * 1000 + counterparty_reserve_we_require_msat {
3735                                 return Err(ChannelError::Close("Funding remote cannot afford proposed new fee".to_owned()));
3736                         }
3737                 }
3738                 #[cfg(any(test, fuzzing))]
3739                 {
3740                         if self.context.is_outbound() {
3741                                 let projected_commit_tx_info = self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap().take();
3742                                 *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
3743                                 if let Some(info) = projected_commit_tx_info {
3744                                         let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len()
3745                                                 + self.context.holding_cell_htlc_updates.len();
3746                                         if info.total_pending_htlcs == total_pending_htlcs
3747                                                 && info.next_holder_htlc_id == self.context.next_holder_htlc_id
3748                                                 && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
3749                                                 && info.feerate == self.context.feerate_per_kw {
3750                                                         assert_eq!(commitment_stats.total_fee_sat, info.fee / 1000);
3751                                                 }
3752                                 }
3753                         }
3754                 }
3755
3756                 if msg.htlc_signatures.len() != commitment_stats.num_nondust_htlcs {
3757                         return Err(ChannelError::Close(format!("Got wrong number of HTLC signatures ({}) from remote. It must be {}", msg.htlc_signatures.len(), commitment_stats.num_nondust_htlcs)));
3758                 }
3759
3760                 // Up to LDK 0.0.115, HTLC information was required to be duplicated in the
3761                 // `htlcs_and_sigs` vec and in the `holder_commitment_tx` itself, both of which were passed
3762                 // in the `ChannelMonitorUpdate`. In 0.0.115, support for having a separate set of
3763                 // outbound-non-dust-HTLCSources in the `ChannelMonitorUpdate` was added, however for
3764                 // backwards compatibility, we never use it in production. To provide test coverage, here,
3765                 // we randomly decide (in test/fuzzing builds) to use the new vec sometimes.
3766                 #[allow(unused_assignments, unused_mut)]
3767                 let mut separate_nondust_htlc_sources = false;
3768                 #[cfg(all(feature = "std", any(test, fuzzing)))] {
3769                         use core::hash::{BuildHasher, Hasher};
3770                         // Get a random value using the only std API to do so - the DefaultHasher
3771                         let rand_val = std::collections::hash_map::RandomState::new().build_hasher().finish();
3772                         separate_nondust_htlc_sources = rand_val % 2 == 0;
3773                 }
3774
3775                 let mut nondust_htlc_sources = Vec::with_capacity(htlcs_cloned.len());
3776                 let mut htlcs_and_sigs = Vec::with_capacity(htlcs_cloned.len());
3777                 for (idx, (htlc, mut source_opt)) in htlcs_cloned.drain(..).enumerate() {
3778                         if let Some(_) = htlc.transaction_output_index {
3779                                 let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_stats.feerate_per_kw,
3780                                         self.context.get_counterparty_selected_contest_delay().unwrap(), &htlc, &self.context.channel_type,
3781                                         &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
3782
3783                                 let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &keys);
3784                                 let htlc_sighashtype = if self.context.channel_type.supports_anchors_zero_fee_htlc_tx() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
3785                                 let htlc_sighash = hash_to_message!(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]);
3786                                 log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}.",
3787                                         log_bytes!(msg.htlc_signatures[idx].serialize_compact()[..]), log_bytes!(keys.countersignatory_htlc_key.to_public_key().serialize()),
3788                                         encode::serialize_hex(&htlc_tx), log_bytes!(htlc_sighash[..]), encode::serialize_hex(&htlc_redeemscript), &self.context.channel_id());
3789                                 if let Err(_) = self.context.secp_ctx.verify_ecdsa(&htlc_sighash, &msg.htlc_signatures[idx], &keys.countersignatory_htlc_key.to_public_key()) {
3790                                         return Err(ChannelError::Close("Invalid HTLC tx signature from peer".to_owned()));
3791                                 }
3792                                 if !separate_nondust_htlc_sources {
3793                                         htlcs_and_sigs.push((htlc, Some(msg.htlc_signatures[idx]), source_opt.take()));
3794                                 }
3795                         } else {
3796                                 htlcs_and_sigs.push((htlc, None, source_opt.take()));
3797                         }
3798                         if separate_nondust_htlc_sources {
3799                                 if let Some(source) = source_opt.take() {
3800                                         nondust_htlc_sources.push(source);
3801                                 }
3802                         }
3803                         debug_assert!(source_opt.is_none(), "HTLCSource should have been put somewhere");
3804                 }
3805
3806                 let holder_commitment_tx = HolderCommitmentTransaction::new(
3807                         commitment_stats.tx,
3808                         msg.signature,
3809                         msg.htlc_signatures.clone(),
3810                         &self.context.get_holder_pubkeys().funding_pubkey,
3811                         self.context.counterparty_funding_pubkey()
3812                 );
3813
3814                 self.context.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, commitment_stats.outbound_htlc_preimages)
3815                         .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
3816
3817                 // Update state now that we've passed all the can-fail calls...
3818                 let mut need_commitment = false;
3819                 if let &mut Some((_, ref mut update_state)) = &mut self.context.pending_update_fee {
3820                         if *update_state == FeeUpdateState::RemoteAnnounced {
3821                                 *update_state = FeeUpdateState::AwaitingRemoteRevokeToAnnounce;
3822                                 need_commitment = true;
3823                         }
3824                 }
3825
3826                 for htlc in self.context.pending_inbound_htlcs.iter_mut() {
3827                         let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
3828                                 Some(forward_info.clone())
3829                         } else { None };
3830                         if let Some(forward_info) = new_forward {
3831                                 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToAnnounce due to commitment_signed in channel {}.",
3832                                         &htlc.payment_hash, &self.context.channel_id);
3833                                 htlc.state = InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info);
3834                                 need_commitment = true;
3835                         }
3836                 }
3837                 let mut claimed_htlcs = Vec::new();
3838                 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
3839                         if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
3840                                 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
3841                                         &htlc.payment_hash, &self.context.channel_id);
3842                                 // Grab the preimage, if it exists, instead of cloning
3843                                 let mut reason = OutboundHTLCOutcome::Success(None);
3844                                 mem::swap(outcome, &mut reason);
3845                                 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
3846                                         // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
3847                                         // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
3848                                         // have a `Success(None)` reason. In this case we could forget some HTLC
3849                                         // claims, but such an upgrade is unlikely and including claimed HTLCs here
3850                                         // fixes a bug which the user was exposed to on 0.0.104 when they started the
3851                                         // claim anyway.
3852                                         claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
3853                                 }
3854                                 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
3855                                 need_commitment = true;
3856                         }
3857                 }
3858
3859                 self.context.latest_monitor_update_id += 1;
3860                 let mut monitor_update = ChannelMonitorUpdate {
3861                         update_id: self.context.latest_monitor_update_id,
3862                         counterparty_node_id: Some(self.context.counterparty_node_id),
3863                         updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
3864                                 commitment_tx: holder_commitment_tx,
3865                                 htlc_outputs: htlcs_and_sigs,
3866                                 claimed_htlcs,
3867                                 nondust_htlc_sources,
3868                         }],
3869                         channel_id: Some(self.context.channel_id()),
3870                 };
3871
3872                 self.context.cur_holder_commitment_transaction_number -= 1;
3873                 self.context.expecting_peer_commitment_signed = false;
3874                 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
3875                 // build_commitment_no_status_check() next which will reset this to RAAFirst.
3876                 self.context.resend_order = RAACommitmentOrder::CommitmentFirst;
3877
3878                 if self.context.channel_state.is_monitor_update_in_progress() {
3879                         // In case we initially failed monitor updating without requiring a response, we need
3880                         // to make sure the RAA gets sent first.
3881                         self.context.monitor_pending_revoke_and_ack = true;
3882                         if need_commitment && !self.context.channel_state.is_awaiting_remote_revoke() {
3883                                 // If we were going to send a commitment_signed after the RAA, go ahead and do all
3884                                 // the corresponding HTLC status updates so that
3885                                 // get_last_commitment_update_for_send includes the right HTLCs.
3886                                 self.context.monitor_pending_commitment_signed = true;
3887                                 let mut additional_update = self.build_commitment_no_status_check(logger);
3888                                 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3889                                 // strictly increasing by one, so decrement it here.
3890                                 self.context.latest_monitor_update_id = monitor_update.update_id;
3891                                 monitor_update.updates.append(&mut additional_update.updates);
3892                         }
3893                         log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updated HTLC state but awaiting a monitor update resolution to reply.",
3894                                 &self.context.channel_id);
3895                         return Ok(self.push_ret_blockable_mon_update(monitor_update));
3896                 }
3897
3898                 let need_commitment_signed = if need_commitment && !self.context.channel_state.is_awaiting_remote_revoke() {
3899                         // If we're AwaitingRemoteRevoke we can't send a new commitment here, but that's ok -
3900                         // we'll send one right away when we get the revoke_and_ack when we
3901                         // free_holding_cell_htlcs().
3902                         let mut additional_update = self.build_commitment_no_status_check(logger);
3903                         // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3904                         // strictly increasing by one, so decrement it here.
3905                         self.context.latest_monitor_update_id = monitor_update.update_id;
3906                         monitor_update.updates.append(&mut additional_update.updates);
3907                         true
3908                 } else { false };
3909
3910                 log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updating HTLC state and responding with{} a revoke_and_ack.",
3911                         &self.context.channel_id(), if need_commitment_signed { " our own commitment_signed and" } else { "" });
3912                 self.monitor_updating_paused(true, need_commitment_signed, false, Vec::new(), Vec::new(), Vec::new());
3913                 return Ok(self.push_ret_blockable_mon_update(monitor_update));
3914         }
3915
3916         /// Public version of the below, checking relevant preconditions first.
3917         /// If we're not in a state where freeing the holding cell makes sense, this is a no-op and
3918         /// returns `(None, Vec::new())`.
3919         pub fn maybe_free_holding_cell_htlcs<F: Deref, L: Deref>(
3920                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
3921         ) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>)
3922         where F::Target: FeeEstimator, L::Target: Logger
3923         {
3924                 if matches!(self.context.channel_state, ChannelState::ChannelReady(_)) && self.context.channel_state.can_generate_new_commitment() {
3925                         self.free_holding_cell_htlcs(fee_estimator, logger)
3926                 } else { (None, Vec::new()) }
3927         }
3928
3929         /// Frees any pending commitment updates in the holding cell, generating the relevant messages
3930         /// for our counterparty.
3931         fn free_holding_cell_htlcs<F: Deref, L: Deref>(
3932                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
3933         ) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>)
3934         where F::Target: FeeEstimator, L::Target: Logger
3935         {
3936                 assert!(!self.context.channel_state.is_monitor_update_in_progress());
3937                 if self.context.holding_cell_htlc_updates.len() != 0 || self.context.holding_cell_update_fee.is_some() {
3938                         log_trace!(logger, "Freeing holding cell with {} HTLC updates{} in channel {}", self.context.holding_cell_htlc_updates.len(),
3939                                 if self.context.holding_cell_update_fee.is_some() { " and a fee update" } else { "" }, &self.context.channel_id());
3940
3941                         let mut monitor_update = ChannelMonitorUpdate {
3942                                 update_id: self.context.latest_monitor_update_id + 1, // We don't increment this yet!
3943                                 counterparty_node_id: Some(self.context.counterparty_node_id),
3944                                 updates: Vec::new(),
3945                                 channel_id: Some(self.context.channel_id()),
3946                         };
3947
3948                         let mut htlc_updates = Vec::new();
3949                         mem::swap(&mut htlc_updates, &mut self.context.holding_cell_htlc_updates);
3950                         let mut update_add_count = 0;
3951                         let mut update_fulfill_count = 0;
3952                         let mut update_fail_count = 0;
3953                         let mut htlcs_to_fail = Vec::new();
3954                         for htlc_update in htlc_updates.drain(..) {
3955                                 // Note that this *can* fail, though it should be due to rather-rare conditions on
3956                                 // fee races with adding too many outputs which push our total payments just over
3957                                 // the limit. In case it's less rare than I anticipate, we may want to revisit
3958                                 // handling this case better and maybe fulfilling some of the HTLCs while attempting
3959                                 // to rebalance channels.
3960                                 let fail_htlc_res = match &htlc_update {
3961                                         &HTLCUpdateAwaitingACK::AddHTLC {
3962                                                 amount_msat, cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet,
3963                                                 skimmed_fee_msat, blinding_point, ..
3964                                         } => {
3965                                                 match self.send_htlc(
3966                                                         amount_msat, *payment_hash, cltv_expiry, source.clone(), onion_routing_packet.clone(),
3967                                                         false, skimmed_fee_msat, blinding_point, fee_estimator, logger
3968                                                 ) {
3969                                                         Ok(_) => update_add_count += 1,
3970                                                         Err(e) => {
3971                                                                 match e {
3972                                                                         ChannelError::Ignore(ref msg) => {
3973                                                                                 log_info!(logger, "Failed to send HTLC with payment_hash {} due to {} in channel {}", &payment_hash, msg, &self.context.channel_id());
3974                                                                                 // If we fail to send here, then this HTLC should
3975                                                                                 // be failed backwards. Failing to send here
3976                                                                                 // indicates that this HTLC may keep being put back
3977                                                                                 // into the holding cell without ever being
3978                                                                                 // successfully forwarded/failed/fulfilled, causing
3979                                                                                 // our counterparty to eventually close on us.
3980                                                                                 htlcs_to_fail.push((source.clone(), *payment_hash));
3981                                                                         },
3982                                                                         _ => {
3983                                                                                 panic!("Got a non-IgnoreError action trying to send holding cell HTLC");
3984                                                                         },
3985                                                                 }
3986                                                         }
3987                                                 }
3988                                                 None
3989                                         },
3990                                         &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, htlc_id, .. } => {
3991                                                 // If an HTLC claim was previously added to the holding cell (via
3992                                                 // `get_update_fulfill_htlc`, then generating the claim message itself must
3993                                                 // not fail - any in between attempts to claim the HTLC will have resulted
3994                                                 // in it hitting the holding cell again and we cannot change the state of a
3995                                                 // holding cell HTLC from fulfill to anything else.
3996                                                 let mut additional_monitor_update =
3997                                                         if let UpdateFulfillFetch::NewClaim { monitor_update, .. } =
3998                                                                 self.get_update_fulfill_htlc(htlc_id, *payment_preimage, logger)
3999                                                         { monitor_update } else { unreachable!() };
4000                                                 update_fulfill_count += 1;
4001                                                 monitor_update.updates.append(&mut additional_monitor_update.updates);
4002                                                 None
4003                                         },
4004                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, ref err_packet } => {
4005                                                 Some(self.fail_htlc(htlc_id, err_packet.clone(), false, logger)
4006                                                  .map(|fail_msg_opt| fail_msg_opt.map(|_| ())))
4007                                         },
4008                                         &HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, failure_code, sha256_of_onion } => {
4009                                                 Some(self.fail_htlc(htlc_id, (sha256_of_onion, failure_code), false, logger)
4010                                                  .map(|fail_msg_opt| fail_msg_opt.map(|_| ())))
4011                                         }
4012                                 };
4013                                 if let Some(res) = fail_htlc_res {
4014                                         match res {
4015                                                 Ok(fail_msg_opt) => {
4016                                                         // If an HTLC failure was previously added to the holding cell (via
4017                                                         // `queue_fail_{malformed_}htlc`) then generating the fail message itself must
4018                                                         // not fail - we should never end up in a state where we double-fail
4019                                                         // an HTLC or fail-then-claim an HTLC as it indicates we didn't wait
4020                                                         // for a full revocation before failing.
4021                                                         debug_assert!(fail_msg_opt.is_some());
4022                                                         update_fail_count += 1;
4023                                                 },
4024                                                 Err(ChannelError::Ignore(_)) => {},
4025                                                 Err(_) => {
4026                                                         panic!("Got a non-IgnoreError action trying to fail holding cell HTLC");
4027                                                 },
4028                                         }
4029                                 }
4030                         }
4031                         if update_add_count == 0 && update_fulfill_count == 0 && update_fail_count == 0 && self.context.holding_cell_update_fee.is_none() {
4032                                 return (None, htlcs_to_fail);
4033                         }
4034                         let update_fee = if let Some(feerate) = self.context.holding_cell_update_fee.take() {
4035                                 self.send_update_fee(feerate, false, fee_estimator, logger)
4036                         } else {
4037                                 None
4038                         };
4039
4040                         let mut additional_update = self.build_commitment_no_status_check(logger);
4041                         // build_commitment_no_status_check and get_update_fulfill_htlc may bump latest_monitor_id
4042                         // but we want them to be strictly increasing by one, so reset it here.
4043                         self.context.latest_monitor_update_id = monitor_update.update_id;
4044                         monitor_update.updates.append(&mut additional_update.updates);
4045
4046                         log_debug!(logger, "Freeing holding cell in channel {} resulted in {}{} HTLCs added, {} HTLCs fulfilled, and {} HTLCs failed.",
4047                                 &self.context.channel_id(), if update_fee.is_some() { "a fee update, " } else { "" },
4048                                 update_add_count, update_fulfill_count, update_fail_count);
4049
4050                         self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
4051                         (self.push_ret_blockable_mon_update(monitor_update), htlcs_to_fail)
4052                 } else {
4053                         (None, Vec::new())
4054                 }
4055         }
4056
4057         /// Handles receiving a remote's revoke_and_ack. Note that we may return a new
4058         /// commitment_signed message here in case we had pending outbound HTLCs to add which were
4059         /// waiting on this revoke_and_ack. The generation of this new commitment_signed may also fail,
4060         /// generating an appropriate error *after* the channel state has been updated based on the
4061         /// revoke_and_ack message.
4062         pub fn revoke_and_ack<F: Deref, L: Deref>(&mut self, msg: &msgs::RevokeAndACK,
4063                 fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L, hold_mon_update: bool,
4064         ) -> Result<(Vec<(HTLCSource, PaymentHash)>, Option<ChannelMonitorUpdate>), ChannelError>
4065         where F::Target: FeeEstimator, L::Target: Logger,
4066         {
4067                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
4068                         return Err(ChannelError::Close("Got revoke/ACK message when channel was not in an operational state".to_owned()));
4069                 }
4070                 if self.context.channel_state.is_peer_disconnected() {
4071                         return Err(ChannelError::Close("Peer sent revoke_and_ack when we needed a channel_reestablish".to_owned()));
4072                 }
4073                 if self.context.channel_state.is_both_sides_shutdown() && self.context.last_sent_closing_fee.is_some() {
4074                         return Err(ChannelError::Close("Peer sent revoke_and_ack after we'd started exchanging closing_signeds".to_owned()));
4075                 }
4076
4077                 let secret = secp_check!(SecretKey::from_slice(&msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret".to_owned());
4078
4079                 if let Some(counterparty_prev_commitment_point) = self.context.counterparty_prev_commitment_point {
4080                         if PublicKey::from_secret_key(&self.context.secp_ctx, &secret) != counterparty_prev_commitment_point {
4081                                 return Err(ChannelError::Close("Got a revoke commitment secret which didn't correspond to their current pubkey".to_owned()));
4082                         }
4083                 }
4084
4085                 if !self.context.channel_state.is_awaiting_remote_revoke() {
4086                         // Our counterparty seems to have burned their coins to us (by revoking a state when we
4087                         // haven't given them a new commitment transaction to broadcast). We should probably
4088                         // take advantage of this by updating our channel monitor, sending them an error, and
4089                         // waiting for them to broadcast their latest (now-revoked claim). But, that would be a
4090                         // lot of work, and there's some chance this is all a misunderstanding anyway.
4091                         // We have to do *something*, though, since our signer may get mad at us for otherwise
4092                         // jumping a remote commitment number, so best to just force-close and move on.
4093                         return Err(ChannelError::Close("Received an unexpected revoke_and_ack".to_owned()));
4094                 }
4095
4096                 #[cfg(any(test, fuzzing))]
4097                 {
4098                         *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
4099                         *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
4100                 }
4101
4102                 match &self.context.holder_signer {
4103                         ChannelSignerType::Ecdsa(ecdsa) => {
4104                                 ecdsa.validate_counterparty_revocation(
4105                                         self.context.cur_counterparty_commitment_transaction_number + 1,
4106                                         &secret
4107                                 ).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
4108                         },
4109                         // TODO (taproot|arik)
4110                         #[cfg(taproot)]
4111                         _ => todo!()
4112                 };
4113
4114                 self.context.commitment_secrets.provide_secret(self.context.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
4115                         .map_err(|_| ChannelError::Close("Previous secrets did not match new one".to_owned()))?;
4116                 self.context.latest_monitor_update_id += 1;
4117                 let mut monitor_update = ChannelMonitorUpdate {
4118                         update_id: self.context.latest_monitor_update_id,
4119                         counterparty_node_id: Some(self.context.counterparty_node_id),
4120                         updates: vec![ChannelMonitorUpdateStep::CommitmentSecret {
4121                                 idx: self.context.cur_counterparty_commitment_transaction_number + 1,
4122                                 secret: msg.per_commitment_secret,
4123                         }],
4124                         channel_id: Some(self.context.channel_id()),
4125                 };
4126
4127                 // Update state now that we've passed all the can-fail calls...
4128                 // (note that we may still fail to generate the new commitment_signed message, but that's
4129                 // OK, we step the channel here and *then* if the new generation fails we can fail the
4130                 // channel based on that, but stepping stuff here should be safe either way.
4131                 self.context.channel_state.clear_awaiting_remote_revoke();
4132                 self.context.sent_message_awaiting_response = None;
4133                 self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
4134                 self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
4135                 self.context.cur_counterparty_commitment_transaction_number -= 1;
4136
4137                 if self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
4138                         self.context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
4139                 }
4140
4141                 log_trace!(logger, "Updating HTLCs on receipt of RAA in channel {}...", &self.context.channel_id());
4142                 let mut to_forward_infos = Vec::new();
4143                 let mut revoked_htlcs = Vec::new();
4144                 let mut finalized_claimed_htlcs = Vec::new();
4145                 let mut update_fail_htlcs = Vec::new();
4146                 let mut update_fail_malformed_htlcs = Vec::new();
4147                 let mut require_commitment = false;
4148                 let mut value_to_self_msat_diff: i64 = 0;
4149
4150                 {
4151                         // Take references explicitly so that we can hold multiple references to self.context.
4152                         let pending_inbound_htlcs: &mut Vec<_> = &mut self.context.pending_inbound_htlcs;
4153                         let pending_outbound_htlcs: &mut Vec<_> = &mut self.context.pending_outbound_htlcs;
4154                         let expecting_peer_commitment_signed = &mut self.context.expecting_peer_commitment_signed;
4155
4156                         // We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
4157                         pending_inbound_htlcs.retain(|htlc| {
4158                                 if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
4159                                         log_trace!(logger, " ...removing inbound LocalRemoved {}", &htlc.payment_hash);
4160                                         if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
4161                                                 value_to_self_msat_diff += htlc.amount_msat as i64;
4162                                         }
4163                                         *expecting_peer_commitment_signed = true;
4164                                         false
4165                                 } else { true }
4166                         });
4167                         pending_outbound_htlcs.retain(|htlc| {
4168                                 if let &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) = &htlc.state {
4169                                         log_trace!(logger, " ...removing outbound AwaitingRemovedRemoteRevoke {}", &htlc.payment_hash);
4170                                         if let OutboundHTLCOutcome::Failure(reason) = outcome.clone() { // We really want take() here, but, again, non-mut ref :(
4171                                                 revoked_htlcs.push((htlc.source.clone(), htlc.payment_hash, reason));
4172                                         } else {
4173                                                 finalized_claimed_htlcs.push(htlc.source.clone());
4174                                                 // They fulfilled, so we sent them money
4175                                                 value_to_self_msat_diff -= htlc.amount_msat as i64;
4176                                         }
4177                                         false
4178                                 } else { true }
4179                         });
4180                         for htlc in pending_inbound_htlcs.iter_mut() {
4181                                 let swap = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) = &htlc.state {
4182                                         true
4183                                 } else if let &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) = &htlc.state {
4184                                         true
4185                                 } else { false };
4186                                 if swap {
4187                                         let mut state = InboundHTLCState::Committed;
4188                                         mem::swap(&mut state, &mut htlc.state);
4189
4190                                         if let InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info) = state {
4191                                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", &htlc.payment_hash);
4192                                                 htlc.state = InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info);
4193                                                 require_commitment = true;
4194                                         } else if let InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info) = state {
4195                                                 match forward_info {
4196                                                         PendingHTLCStatus::Fail(fail_msg) => {
4197                                                                 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to LocalRemoved due to PendingHTLCStatus indicating failure", &htlc.payment_hash);
4198                                                                 require_commitment = true;
4199                                                                 match fail_msg {
4200                                                                         HTLCFailureMsg::Relay(msg) => {
4201                                                                                 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(msg.reason.clone()));
4202                                                                                 update_fail_htlcs.push(msg)
4203                                                                         },
4204                                                                         HTLCFailureMsg::Malformed(msg) => {
4205                                                                                 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed((msg.sha256_of_onion, msg.failure_code)));
4206                                                                                 update_fail_malformed_htlcs.push(msg)
4207                                                                         },
4208                                                                 }
4209                                                         },
4210                                                         PendingHTLCStatus::Forward(forward_info) => {
4211                                                                 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed", &htlc.payment_hash);
4212                                                                 to_forward_infos.push((forward_info, htlc.htlc_id));
4213                                                                 htlc.state = InboundHTLCState::Committed;
4214                                                         }
4215                                                 }
4216                                         }
4217                                 }
4218                         }
4219                         for htlc in pending_outbound_htlcs.iter_mut() {
4220                                 if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
4221                                         log_trace!(logger, " ...promoting outbound LocalAnnounced {} to Committed", &htlc.payment_hash);
4222                                         htlc.state = OutboundHTLCState::Committed;
4223                                         *expecting_peer_commitment_signed = true;
4224                                 }
4225                                 if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
4226                                         log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", &htlc.payment_hash);
4227                                         // Grab the preimage, if it exists, instead of cloning
4228                                         let mut reason = OutboundHTLCOutcome::Success(None);
4229                                         mem::swap(outcome, &mut reason);
4230                                         htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
4231                                         require_commitment = true;
4232                                 }
4233                         }
4234                 }
4235                 self.context.value_to_self_msat = (self.context.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
4236
4237                 if let Some((feerate, update_state)) = self.context.pending_update_fee {
4238                         match update_state {
4239                                 FeeUpdateState::Outbound => {
4240                                         debug_assert!(self.context.is_outbound());
4241                                         log_trace!(logger, " ...promoting outbound fee update {} to Committed", feerate);
4242                                         self.context.feerate_per_kw = feerate;
4243                                         self.context.pending_update_fee = None;
4244                                         self.context.expecting_peer_commitment_signed = true;
4245                                 },
4246                                 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.context.is_outbound()); },
4247                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => {
4248                                         debug_assert!(!self.context.is_outbound());
4249                                         log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
4250                                         require_commitment = true;
4251                                         self.context.feerate_per_kw = feerate;
4252                                         self.context.pending_update_fee = None;
4253                                 },
4254                         }
4255                 }
4256
4257                 let release_monitor = self.context.blocked_monitor_updates.is_empty() && !hold_mon_update;
4258                 let release_state_str =
4259                         if hold_mon_update { "Holding" } else if release_monitor { "Releasing" } else { "Blocked" };
4260                 macro_rules! return_with_htlcs_to_fail {
4261                         ($htlcs_to_fail: expr) => {
4262                                 if !release_monitor {
4263                                         self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
4264                                                 update: monitor_update,
4265                                         });
4266                                         return Ok(($htlcs_to_fail, None));
4267                                 } else {
4268                                         return Ok(($htlcs_to_fail, Some(monitor_update)));
4269                                 }
4270                         }
4271                 }
4272
4273                 if self.context.channel_state.is_monitor_update_in_progress() {
4274                         // We can't actually generate a new commitment transaction (incl by freeing holding
4275                         // cells) while we can't update the monitor, so we just return what we have.
4276                         if require_commitment {
4277                                 self.context.monitor_pending_commitment_signed = true;
4278                                 // When the monitor updating is restored we'll call
4279                                 // get_last_commitment_update_for_send(), which does not update state, but we're
4280                                 // definitely now awaiting a remote revoke before we can step forward any more, so
4281                                 // set it here.
4282                                 let mut additional_update = self.build_commitment_no_status_check(logger);
4283                                 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
4284                                 // strictly increasing by one, so decrement it here.
4285                                 self.context.latest_monitor_update_id = monitor_update.update_id;
4286                                 monitor_update.updates.append(&mut additional_update.updates);
4287                         }
4288                         self.context.monitor_pending_forwards.append(&mut to_forward_infos);
4289                         self.context.monitor_pending_failures.append(&mut revoked_htlcs);
4290                         self.context.monitor_pending_finalized_fulfills.append(&mut finalized_claimed_htlcs);
4291                         log_debug!(logger, "Received a valid revoke_and_ack for channel {} but awaiting a monitor update resolution to reply.", &self.context.channel_id());
4292                         return_with_htlcs_to_fail!(Vec::new());
4293                 }
4294
4295                 match self.free_holding_cell_htlcs(fee_estimator, logger) {
4296                         (Some(mut additional_update), htlcs_to_fail) => {
4297                                 // free_holding_cell_htlcs may bump latest_monitor_id multiple times but we want them to be
4298                                 // strictly increasing by one, so decrement it here.
4299                                 self.context.latest_monitor_update_id = monitor_update.update_id;
4300                                 monitor_update.updates.append(&mut additional_update.updates);
4301
4302                                 log_debug!(logger, "Received a valid revoke_and_ack for channel {} with holding cell HTLCs freed. {} monitor update.",
4303                                         &self.context.channel_id(), release_state_str);
4304
4305                                 self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
4306                                 return_with_htlcs_to_fail!(htlcs_to_fail);
4307                         },
4308                         (None, htlcs_to_fail) => {
4309                                 if require_commitment {
4310                                         let mut additional_update = self.build_commitment_no_status_check(logger);
4311
4312                                         // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
4313                                         // strictly increasing by one, so decrement it here.
4314                                         self.context.latest_monitor_update_id = monitor_update.update_id;
4315                                         monitor_update.updates.append(&mut additional_update.updates);
4316
4317                                         log_debug!(logger, "Received a valid revoke_and_ack for channel {}. Responding with a commitment update with {} HTLCs failed. {} monitor update.",
4318                                                 &self.context.channel_id(),
4319                                                 update_fail_htlcs.len() + update_fail_malformed_htlcs.len(),
4320                                                 release_state_str);
4321
4322                                         self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
4323                                         return_with_htlcs_to_fail!(htlcs_to_fail);
4324                                 } else {
4325                                         log_debug!(logger, "Received a valid revoke_and_ack for channel {} with no reply necessary. {} monitor update.",
4326                                                 &self.context.channel_id(), release_state_str);
4327
4328                                         self.monitor_updating_paused(false, false, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
4329                                         return_with_htlcs_to_fail!(htlcs_to_fail);
4330                                 }
4331                         }
4332                 }
4333         }
4334
4335         /// Queues up an outbound update fee by placing it in the holding cell. You should call
4336         /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
4337         /// commitment update.
4338         pub fn queue_update_fee<F: Deref, L: Deref>(&mut self, feerate_per_kw: u32,
4339                 fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
4340         where F::Target: FeeEstimator, L::Target: Logger
4341         {
4342                 let msg_opt = self.send_update_fee(feerate_per_kw, true, fee_estimator, logger);
4343                 assert!(msg_opt.is_none(), "We forced holding cell?");
4344         }
4345
4346         /// Adds a pending update to this channel. See the doc for send_htlc for
4347         /// further details on the optionness of the return value.
4348         /// If our balance is too low to cover the cost of the next commitment transaction at the
4349         /// new feerate, the update is cancelled.
4350         ///
4351         /// You MUST call [`Self::send_commitment_no_state_update`] prior to any other calls on this
4352         /// [`Channel`] if `force_holding_cell` is false.
4353         fn send_update_fee<F: Deref, L: Deref>(
4354                 &mut self, feerate_per_kw: u32, mut force_holding_cell: bool,
4355                 fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
4356         ) -> Option<msgs::UpdateFee>
4357         where F::Target: FeeEstimator, L::Target: Logger
4358         {
4359                 if !self.context.is_outbound() {
4360                         panic!("Cannot send fee from inbound channel");
4361                 }
4362                 if !self.context.is_usable() {
4363                         panic!("Cannot update fee until channel is fully established and we haven't started shutting down");
4364                 }
4365                 if !self.context.is_live() {
4366                         panic!("Cannot update fee while peer is disconnected/we're awaiting a monitor update (ChannelManager should have caught this)");
4367                 }
4368
4369                 // Before proposing a feerate update, check that we can actually afford the new fee.
4370                 let inbound_stats = self.context.get_inbound_pending_htlc_stats(Some(feerate_per_kw));
4371                 let outbound_stats = self.context.get_outbound_pending_htlc_stats(Some(feerate_per_kw));
4372                 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
4373                 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, true, logger);
4374                 let buffer_fee_msat = commit_tx_fee_sat(feerate_per_kw, commitment_stats.num_nondust_htlcs + outbound_stats.on_holder_tx_holding_cell_htlcs_count as usize + CONCURRENT_INBOUND_HTLC_FEE_BUFFER as usize, self.context.get_channel_type()) * 1000;
4375                 let holder_balance_msat = commitment_stats.local_balance_msat - outbound_stats.holding_cell_msat;
4376                 if holder_balance_msat < buffer_fee_msat  + self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 {
4377                         //TODO: auto-close after a number of failures?
4378                         log_debug!(logger, "Cannot afford to send new feerate at {}", feerate_per_kw);
4379                         return None;
4380                 }
4381
4382                 // Note, we evaluate pending htlc "preemptive" trimmed-to-dust threshold at the proposed `feerate_per_kw`.
4383                 let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
4384                 let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
4385                 let max_dust_htlc_exposure_msat = self.context.get_max_dust_htlc_exposure_msat(fee_estimator);
4386                 if holder_tx_dust_exposure > max_dust_htlc_exposure_msat {
4387                         log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
4388                         return None;
4389                 }
4390                 if counterparty_tx_dust_exposure > max_dust_htlc_exposure_msat {
4391                         log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
4392                         return None;
4393                 }
4394
4395                 if self.context.channel_state.is_awaiting_remote_revoke() || self.context.channel_state.is_monitor_update_in_progress() {
4396                         force_holding_cell = true;
4397                 }
4398
4399                 if force_holding_cell {
4400                         self.context.holding_cell_update_fee = Some(feerate_per_kw);
4401                         return None;
4402                 }
4403
4404                 debug_assert!(self.context.pending_update_fee.is_none());
4405                 self.context.pending_update_fee = Some((feerate_per_kw, FeeUpdateState::Outbound));
4406
4407                 Some(msgs::UpdateFee {
4408                         channel_id: self.context.channel_id,
4409                         feerate_per_kw,
4410                 })
4411         }
4412
4413         /// Removes any uncommitted inbound HTLCs and resets the state of uncommitted outbound HTLC
4414         /// updates, to be used on peer disconnection. After this, update_*_htlc messages need to be
4415         /// resent.
4416         /// No further message handling calls may be made until a channel_reestablish dance has
4417         /// completed.
4418         /// May return `Err(())`, which implies [`ChannelContext::force_shutdown`] should be called immediately.
4419         pub fn remove_uncommitted_htlcs_and_mark_paused<L: Deref>(&mut self, logger: &L) -> Result<(), ()> where L::Target: Logger {
4420                 assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
4421                 if self.context.channel_state.is_pre_funded_state() {
4422                         return Err(())
4423                 }
4424
4425                 if self.context.channel_state.is_peer_disconnected() {
4426                         // While the below code should be idempotent, it's simpler to just return early, as
4427                         // redundant disconnect events can fire, though they should be rare.
4428                         return Ok(());
4429                 }
4430
4431                 if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent || self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
4432                         self.context.announcement_sigs_state = AnnouncementSigsState::NotSent;
4433                 }
4434
4435                 // Upon reconnect we have to start the closing_signed dance over, but shutdown messages
4436                 // will be retransmitted.
4437                 self.context.last_sent_closing_fee = None;
4438                 self.context.pending_counterparty_closing_signed = None;
4439                 self.context.closing_fee_limits = None;
4440
4441                 let mut inbound_drop_count = 0;
4442                 self.context.pending_inbound_htlcs.retain(|htlc| {
4443                         match htlc.state {
4444                                 InboundHTLCState::RemoteAnnounced(_) => {
4445                                         // They sent us an update_add_htlc but we never got the commitment_signed.
4446                                         // We'll tell them what commitment_signed we're expecting next and they'll drop
4447                                         // this HTLC accordingly
4448                                         inbound_drop_count += 1;
4449                                         false
4450                                 },
4451                                 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_)|InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => {
4452                                         // We received a commitment_signed updating this HTLC and (at least hopefully)
4453                                         // sent a revoke_and_ack (which we can re-transmit) and have heard nothing
4454                                         // in response to it yet, so don't touch it.
4455                                         true
4456                                 },
4457                                 InboundHTLCState::Committed => true,
4458                                 InboundHTLCState::LocalRemoved(_) => {
4459                                         // We (hopefully) sent a commitment_signed updating this HTLC (which we can
4460                                         // re-transmit if needed) and they may have even sent a revoke_and_ack back
4461                                         // (that we missed). Keep this around for now and if they tell us they missed
4462                                         // the commitment_signed we can re-transmit the update then.
4463                                         true
4464                                 },
4465                         }
4466                 });
4467                 self.context.next_counterparty_htlc_id -= inbound_drop_count;
4468
4469                 if let Some((_, update_state)) = self.context.pending_update_fee {
4470                         if update_state == FeeUpdateState::RemoteAnnounced {
4471                                 debug_assert!(!self.context.is_outbound());
4472                                 self.context.pending_update_fee = None;
4473                         }
4474                 }
4475
4476                 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
4477                         if let OutboundHTLCState::RemoteRemoved(_) = htlc.state {
4478                                 // They sent us an update to remove this but haven't yet sent the corresponding
4479                                 // commitment_signed, we need to move it back to Committed and they can re-send
4480                                 // the update upon reconnection.
4481                                 htlc.state = OutboundHTLCState::Committed;
4482                         }
4483                 }
4484
4485                 self.context.sent_message_awaiting_response = None;
4486
4487                 self.context.channel_state.set_peer_disconnected();
4488                 log_trace!(logger, "Peer disconnection resulted in {} remote-announced HTLC drops on channel {}", inbound_drop_count, &self.context.channel_id());
4489                 Ok(())
4490         }
4491
4492         /// Indicates that a ChannelMonitor update is in progress and has not yet been fully persisted.
4493         /// This must be called before we return the [`ChannelMonitorUpdate`] back to the
4494         /// [`ChannelManager`], which will call [`Self::monitor_updating_restored`] once the monitor
4495         /// update completes (potentially immediately).
4496         /// The messages which were generated with the monitor update must *not* have been sent to the
4497         /// remote end, and must instead have been dropped. They will be regenerated when
4498         /// [`Self::monitor_updating_restored`] is called.
4499         ///
4500         /// [`ChannelManager`]: super::channelmanager::ChannelManager
4501         /// [`chain::Watch`]: crate::chain::Watch
4502         /// [`ChannelMonitorUpdateStatus::InProgress`]: crate::chain::ChannelMonitorUpdateStatus::InProgress
4503         fn monitor_updating_paused(&mut self, resend_raa: bool, resend_commitment: bool,
4504                 resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
4505                 mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
4506                 mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
4507         ) {
4508                 self.context.monitor_pending_revoke_and_ack |= resend_raa;
4509                 self.context.monitor_pending_commitment_signed |= resend_commitment;
4510                 self.context.monitor_pending_channel_ready |= resend_channel_ready;
4511                 self.context.monitor_pending_forwards.append(&mut pending_forwards);
4512                 self.context.monitor_pending_failures.append(&mut pending_fails);
4513                 self.context.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
4514                 self.context.channel_state.set_monitor_update_in_progress();
4515         }
4516
4517         /// Indicates that the latest ChannelMonitor update has been committed by the client
4518         /// successfully and we should restore normal operation. Returns messages which should be sent
4519         /// to the remote side.
4520         pub fn monitor_updating_restored<L: Deref, NS: Deref>(
4521                 &mut self, logger: &L, node_signer: &NS, chain_hash: ChainHash,
4522                 user_config: &UserConfig, best_block_height: u32
4523         ) -> MonitorRestoreUpdates
4524         where
4525                 L::Target: Logger,
4526                 NS::Target: NodeSigner
4527         {
4528                 assert!(self.context.channel_state.is_monitor_update_in_progress());
4529                 self.context.channel_state.clear_monitor_update_in_progress();
4530
4531                 // If we're past (or at) the AwaitingChannelReady stage on an outbound channel, try to
4532                 // (re-)broadcast the funding transaction as we may have declined to broadcast it when we
4533                 // first received the funding_signed.
4534                 let mut funding_broadcastable =
4535                         if self.context.is_outbound() &&
4536                                 (matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(flags) if !flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH)) ||
4537                                 matches!(self.context.channel_state, ChannelState::ChannelReady(_)))
4538                         {
4539                                 self.context.funding_transaction.take()
4540                         } else { None };
4541                 // That said, if the funding transaction is already confirmed (ie we're active with a
4542                 // minimum_depth over 0) don't bother re-broadcasting the confirmed funding tx.
4543                 if matches!(self.context.channel_state, ChannelState::ChannelReady(_)) && self.context.minimum_depth != Some(0) {
4544                         funding_broadcastable = None;
4545                 }
4546
4547                 // We will never broadcast the funding transaction when we're in MonitorUpdateInProgress
4548                 // (and we assume the user never directly broadcasts the funding transaction and waits for
4549                 // us to do it). Thus, we can only ever hit monitor_pending_channel_ready when we're
4550                 // * an inbound channel that failed to persist the monitor on funding_created and we got
4551                 //   the funding transaction confirmed before the monitor was persisted, or
4552                 // * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
4553                 let channel_ready = if self.context.monitor_pending_channel_ready {
4554                         assert!(!self.context.is_outbound() || self.context.minimum_depth == Some(0),
4555                                 "Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
4556                         self.context.monitor_pending_channel_ready = false;
4557                         let next_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
4558                         Some(msgs::ChannelReady {
4559                                 channel_id: self.context.channel_id(),
4560                                 next_per_commitment_point,
4561                                 short_channel_id_alias: Some(self.context.outbound_scid_alias),
4562                         })
4563                 } else { None };
4564
4565                 let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block_height, logger);
4566
4567                 let mut accepted_htlcs = Vec::new();
4568                 mem::swap(&mut accepted_htlcs, &mut self.context.monitor_pending_forwards);
4569                 let mut failed_htlcs = Vec::new();
4570                 mem::swap(&mut failed_htlcs, &mut self.context.monitor_pending_failures);
4571                 let mut finalized_claimed_htlcs = Vec::new();
4572                 mem::swap(&mut finalized_claimed_htlcs, &mut self.context.monitor_pending_finalized_fulfills);
4573
4574                 if self.context.channel_state.is_peer_disconnected() {
4575                         self.context.monitor_pending_revoke_and_ack = false;
4576                         self.context.monitor_pending_commitment_signed = false;
4577                         return MonitorRestoreUpdates {
4578                                 raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
4579                                 accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
4580                         };
4581                 }
4582
4583                 let raa = if self.context.monitor_pending_revoke_and_ack {
4584                         Some(self.get_last_revoke_and_ack())
4585                 } else { None };
4586                 let commitment_update = if self.context.monitor_pending_commitment_signed {
4587                         self.get_last_commitment_update_for_send(logger).ok()
4588                 } else { None };
4589                 if commitment_update.is_some() {
4590                         self.mark_awaiting_response();
4591                 }
4592
4593                 self.context.monitor_pending_revoke_and_ack = false;
4594                 self.context.monitor_pending_commitment_signed = false;
4595                 let order = self.context.resend_order.clone();
4596                 log_debug!(logger, "Restored monitor updating in channel {} resulting in {}{} commitment update and {} RAA, with {} first",
4597                         &self.context.channel_id(), if funding_broadcastable.is_some() { "a funding broadcastable, " } else { "" },
4598                         if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
4599                         match order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
4600                 MonitorRestoreUpdates {
4601                         raa, commitment_update, order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
4602                 }
4603         }
4604
4605         pub fn update_fee<F: Deref, L: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::UpdateFee, logger: &L) -> Result<(), ChannelError>
4606                 where F::Target: FeeEstimator, L::Target: Logger
4607         {
4608                 if self.context.is_outbound() {
4609                         return Err(ChannelError::Close("Non-funding remote tried to update channel fee".to_owned()));
4610                 }
4611                 if self.context.channel_state.is_peer_disconnected() {
4612                         return Err(ChannelError::Close("Peer sent update_fee when we needed a channel_reestablish".to_owned()));
4613                 }
4614                 Channel::<SP>::check_remote_fee(&self.context.channel_type, fee_estimator, msg.feerate_per_kw, Some(self.context.feerate_per_kw), logger)?;
4615
4616                 self.context.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
4617                 self.context.update_time_counter += 1;
4618                 // Check that we won't be pushed over our dust exposure limit by the feerate increase.
4619                 if !self.context.channel_type.supports_anchors_zero_fee_htlc_tx() {
4620                         let inbound_stats = self.context.get_inbound_pending_htlc_stats(None);
4621                         let outbound_stats = self.context.get_outbound_pending_htlc_stats(None);
4622                         let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
4623                         let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
4624                         let max_dust_htlc_exposure_msat = self.context.get_max_dust_htlc_exposure_msat(fee_estimator);
4625                         if holder_tx_dust_exposure > max_dust_htlc_exposure_msat {
4626                                 return Err(ChannelError::Close(format!("Peer sent update_fee with a feerate ({}) which may over-expose us to dust-in-flight on our own transactions (totaling {} msat)",
4627                                         msg.feerate_per_kw, holder_tx_dust_exposure)));
4628                         }
4629                         if counterparty_tx_dust_exposure > max_dust_htlc_exposure_msat {
4630                                 return Err(ChannelError::Close(format!("Peer sent update_fee with a feerate ({}) which may over-expose us to dust-in-flight on our counterparty's transactions (totaling {} msat)",
4631                                         msg.feerate_per_kw, counterparty_tx_dust_exposure)));
4632                         }
4633                 }
4634                 Ok(())
4635         }
4636
4637         /// Indicates that the signer may have some signatures for us, so we should retry if we're
4638         /// blocked.
4639         #[cfg(async_signing)]
4640         pub fn signer_maybe_unblocked<L: Deref>(&mut self, logger: &L) -> SignerResumeUpdates where L::Target: Logger {
4641                 let commitment_update = if self.context.signer_pending_commitment_update {
4642                         self.get_last_commitment_update_for_send(logger).ok()
4643                 } else { None };
4644                 let funding_signed = if self.context.signer_pending_funding && !self.context.is_outbound() {
4645                         self.context.get_funding_signed_msg(logger).1
4646                 } else { None };
4647                 let channel_ready = if funding_signed.is_some() {
4648                         self.check_get_channel_ready(0)
4649                 } else { None };
4650
4651                 log_trace!(logger, "Signer unblocked with {} commitment_update, {} funding_signed and {} channel_ready",
4652                         if commitment_update.is_some() { "a" } else { "no" },
4653                         if funding_signed.is_some() { "a" } else { "no" },
4654                         if channel_ready.is_some() { "a" } else { "no" });
4655
4656                 SignerResumeUpdates {
4657                         commitment_update,
4658                         funding_signed,
4659                         channel_ready,
4660                 }
4661         }
4662
4663         fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
4664                 let next_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
4665                 let per_commitment_secret = self.context.holder_signer.as_ref().release_commitment_secret(self.context.cur_holder_commitment_transaction_number + 2);
4666                 msgs::RevokeAndACK {
4667                         channel_id: self.context.channel_id,
4668                         per_commitment_secret,
4669                         next_per_commitment_point,
4670                         #[cfg(taproot)]
4671                         next_local_nonce: None,
4672                 }
4673         }
4674
4675         /// Gets the last commitment update for immediate sending to our peer.
4676         fn get_last_commitment_update_for_send<L: Deref>(&mut self, logger: &L) -> Result<msgs::CommitmentUpdate, ()> where L::Target: Logger {
4677                 let mut update_add_htlcs = Vec::new();
4678                 let mut update_fulfill_htlcs = Vec::new();
4679                 let mut update_fail_htlcs = Vec::new();
4680                 let mut update_fail_malformed_htlcs = Vec::new();
4681
4682                 for htlc in self.context.pending_outbound_htlcs.iter() {
4683                         if let &OutboundHTLCState::LocalAnnounced(ref onion_packet) = &htlc.state {
4684                                 update_add_htlcs.push(msgs::UpdateAddHTLC {
4685                                         channel_id: self.context.channel_id(),
4686                                         htlc_id: htlc.htlc_id,
4687                                         amount_msat: htlc.amount_msat,
4688                                         payment_hash: htlc.payment_hash,
4689                                         cltv_expiry: htlc.cltv_expiry,
4690                                         onion_routing_packet: (**onion_packet).clone(),
4691                                         skimmed_fee_msat: htlc.skimmed_fee_msat,
4692                                         blinding_point: htlc.blinding_point,
4693                                 });
4694                         }
4695                 }
4696
4697                 for htlc in self.context.pending_inbound_htlcs.iter() {
4698                         if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
4699                                 match reason {
4700                                         &InboundHTLCRemovalReason::FailRelay(ref err_packet) => {
4701                                                 update_fail_htlcs.push(msgs::UpdateFailHTLC {
4702                                                         channel_id: self.context.channel_id(),
4703                                                         htlc_id: htlc.htlc_id,
4704                                                         reason: err_packet.clone()
4705                                                 });
4706                                         },
4707                                         &InboundHTLCRemovalReason::FailMalformed((ref sha256_of_onion, ref failure_code)) => {
4708                                                 update_fail_malformed_htlcs.push(msgs::UpdateFailMalformedHTLC {
4709                                                         channel_id: self.context.channel_id(),
4710                                                         htlc_id: htlc.htlc_id,
4711                                                         sha256_of_onion: sha256_of_onion.clone(),
4712                                                         failure_code: failure_code.clone(),
4713                                                 });
4714                                         },
4715                                         &InboundHTLCRemovalReason::Fulfill(ref payment_preimage) => {
4716                                                 update_fulfill_htlcs.push(msgs::UpdateFulfillHTLC {
4717                                                         channel_id: self.context.channel_id(),
4718                                                         htlc_id: htlc.htlc_id,
4719                                                         payment_preimage: payment_preimage.clone(),
4720                                                 });
4721                                         },
4722                                 }
4723                         }
4724                 }
4725
4726                 let update_fee = if self.context.is_outbound() && self.context.pending_update_fee.is_some() {
4727                         Some(msgs::UpdateFee {
4728                                 channel_id: self.context.channel_id(),
4729                                 feerate_per_kw: self.context.pending_update_fee.unwrap().0,
4730                         })
4731                 } else { None };
4732
4733                 log_trace!(logger, "Regenerating latest commitment update in channel {} with{} {} update_adds, {} update_fulfills, {} update_fails, and {} update_fail_malformeds",
4734                                 &self.context.channel_id(), if update_fee.is_some() { " update_fee," } else { "" },
4735                                 update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len(), update_fail_malformed_htlcs.len());
4736                 let commitment_signed = if let Ok(update) = self.send_commitment_no_state_update(logger).map(|(cu, _)| cu) {
4737                         if self.context.signer_pending_commitment_update {
4738                                 log_trace!(logger, "Commitment update generated: clearing signer_pending_commitment_update");
4739                                 self.context.signer_pending_commitment_update = false;
4740                         }
4741                         update
4742                 } else {
4743                         #[cfg(not(async_signing))] {
4744                                 panic!("Failed to get signature for new commitment state");
4745                         }
4746                         #[cfg(async_signing)] {
4747                                 if !self.context.signer_pending_commitment_update {
4748                                         log_trace!(logger, "Commitment update awaiting signer: setting signer_pending_commitment_update");
4749                                         self.context.signer_pending_commitment_update = true;
4750                                 }
4751                                 return Err(());
4752                         }
4753                 };
4754                 Ok(msgs::CommitmentUpdate {
4755                         update_add_htlcs, update_fulfill_htlcs, update_fail_htlcs, update_fail_malformed_htlcs, update_fee,
4756                         commitment_signed,
4757                 })
4758         }
4759
4760         /// Gets the `Shutdown` message we should send our peer on reconnect, if any.
4761         pub fn get_outbound_shutdown(&self) -> Option<msgs::Shutdown> {
4762                 if self.context.channel_state.is_local_shutdown_sent() {
4763                         assert!(self.context.shutdown_scriptpubkey.is_some());
4764                         Some(msgs::Shutdown {
4765                                 channel_id: self.context.channel_id,
4766                                 scriptpubkey: self.get_closing_scriptpubkey(),
4767                         })
4768                 } else { None }
4769         }
4770
4771         /// May panic if some calls other than message-handling calls (which will all Err immediately)
4772         /// have been called between remove_uncommitted_htlcs_and_mark_paused and this call.
4773         ///
4774         /// Some links printed in log lines are included here to check them during build (when run with
4775         /// `cargo doc --document-private-items`):
4776         /// [`super::channelmanager::ChannelManager::force_close_without_broadcasting_txn`] and
4777         /// [`super::channelmanager::ChannelManager::force_close_all_channels_without_broadcasting_txn`].
4778         pub fn channel_reestablish<L: Deref, NS: Deref>(
4779                 &mut self, msg: &msgs::ChannelReestablish, logger: &L, node_signer: &NS,
4780                 chain_hash: ChainHash, user_config: &UserConfig, best_block: &BestBlock
4781         ) -> Result<ReestablishResponses, ChannelError>
4782         where
4783                 L::Target: Logger,
4784                 NS::Target: NodeSigner
4785         {
4786                 if !self.context.channel_state.is_peer_disconnected() {
4787                         // While BOLT 2 doesn't indicate explicitly we should error this channel here, it
4788                         // almost certainly indicates we are going to end up out-of-sync in some way, so we
4789                         // just close here instead of trying to recover.
4790                         return Err(ChannelError::Close("Peer sent a loose channel_reestablish not after reconnect".to_owned()));
4791                 }
4792
4793                 if msg.next_local_commitment_number >= INITIAL_COMMITMENT_NUMBER || msg.next_remote_commitment_number >= INITIAL_COMMITMENT_NUMBER ||
4794                         msg.next_local_commitment_number == 0 {
4795                         return Err(ChannelError::Close("Peer sent an invalid channel_reestablish to force close in a non-standard way".to_owned()));
4796                 }
4797
4798                 let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number - 1;
4799                 if msg.next_remote_commitment_number > 0 {
4800                         let expected_point = self.context.holder_signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.context.secp_ctx);
4801                         let given_secret = SecretKey::from_slice(&msg.your_last_per_commitment_secret)
4802                                 .map_err(|_| ChannelError::Close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
4803                         if expected_point != PublicKey::from_secret_key(&self.context.secp_ctx, &given_secret) {
4804                                 return Err(ChannelError::Close("Peer sent a garbage channel_reestablish with secret key not matching the commitment height provided".to_owned()));
4805                         }
4806                         if msg.next_remote_commitment_number > our_commitment_transaction {
4807                                 macro_rules! log_and_panic {
4808                                         ($err_msg: expr) => {
4809                                                 log_error!(logger, $err_msg, &self.context.channel_id, log_pubkey!(self.context.counterparty_node_id));
4810                                                 panic!($err_msg, &self.context.channel_id, log_pubkey!(self.context.counterparty_node_id));
4811                                         }
4812                                 }
4813                                 log_and_panic!("We have fallen behind - we have received proof that if we broadcast our counterparty is going to claim all our funds.\n\
4814                                         This implies you have restarted with lost ChannelMonitor and ChannelManager state, the first of which is a violation of the LDK chain::Watch requirements.\n\
4815                                         More specifically, this means you have a bug in your implementation that can cause loss of funds, or you are running with an old backup, which is unsafe.\n\
4816                                         If you have restored from an old backup and wish to force-close channels and return to operation, you should start up, call\n\
4817                                         ChannelManager::force_close_without_broadcasting_txn on channel {} with counterparty {} or\n\
4818                                         ChannelManager::force_close_all_channels_without_broadcasting_txn, then reconnect to peer(s).\n\
4819                                         Note that due to a long-standing bug in lnd you may have to reach out to peers running lnd-based nodes to ask them to manually force-close channels\n\
4820                                         See https://github.com/lightningdevkit/rust-lightning/issues/1565 for more info.");
4821                         }
4822                 }
4823
4824                 // Before we change the state of the channel, we check if the peer is sending a very old
4825                 // commitment transaction number, if yes we send a warning message.
4826                 if msg.next_remote_commitment_number + 1 < our_commitment_transaction {
4827                         return Err(ChannelError::Warn(format!(
4828                                 "Peer attempted to reestablish channel with a very old local commitment transaction: {} (received) vs {} (expected)",
4829                                 msg.next_remote_commitment_number,
4830                                 our_commitment_transaction
4831                         )));
4832                 }
4833
4834                 // Go ahead and unmark PeerDisconnected as various calls we may make check for it (and all
4835                 // remaining cases either succeed or ErrorMessage-fail).
4836                 self.context.channel_state.clear_peer_disconnected();
4837                 self.context.sent_message_awaiting_response = None;
4838
4839                 let shutdown_msg = self.get_outbound_shutdown();
4840
4841                 let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block.height(), logger);
4842
4843                 if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(_)) {
4844                         // If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
4845                         if !self.context.channel_state.is_our_channel_ready() ||
4846                                         self.context.channel_state.is_monitor_update_in_progress() {
4847                                 if msg.next_remote_commitment_number != 0 {
4848                                         return Err(ChannelError::Close("Peer claimed they saw a revoke_and_ack but we haven't sent channel_ready yet".to_owned()));
4849                                 }
4850                                 // Short circuit the whole handler as there is nothing we can resend them
4851                                 return Ok(ReestablishResponses {
4852                                         channel_ready: None,
4853                                         raa: None, commitment_update: None,
4854                                         order: RAACommitmentOrder::CommitmentFirst,
4855                                         shutdown_msg, announcement_sigs,
4856                                 });
4857                         }
4858
4859                         // We have OurChannelReady set!
4860                         let next_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
4861                         return Ok(ReestablishResponses {
4862                                 channel_ready: Some(msgs::ChannelReady {
4863                                         channel_id: self.context.channel_id(),
4864                                         next_per_commitment_point,
4865                                         short_channel_id_alias: Some(self.context.outbound_scid_alias),
4866                                 }),
4867                                 raa: None, commitment_update: None,
4868                                 order: RAACommitmentOrder::CommitmentFirst,
4869                                 shutdown_msg, announcement_sigs,
4870                         });
4871                 }
4872
4873                 let required_revoke = if msg.next_remote_commitment_number == our_commitment_transaction {
4874                         // Remote isn't waiting on any RevokeAndACK from us!
4875                         // Note that if we need to repeat our ChannelReady we'll do that in the next if block.
4876                         None
4877                 } else if msg.next_remote_commitment_number + 1 == our_commitment_transaction {
4878                         if self.context.channel_state.is_monitor_update_in_progress() {
4879                                 self.context.monitor_pending_revoke_and_ack = true;
4880                                 None
4881                         } else {
4882                                 Some(self.get_last_revoke_and_ack())
4883                         }
4884                 } else {
4885                         debug_assert!(false, "All values should have been handled in the four cases above");
4886                         return Err(ChannelError::Close(format!(
4887                                 "Peer attempted to reestablish channel expecting a future local commitment transaction: {} (received) vs {} (expected)",
4888                                 msg.next_remote_commitment_number,
4889                                 our_commitment_transaction
4890                         )));
4891                 };
4892
4893                 // We increment cur_counterparty_commitment_transaction_number only upon receipt of
4894                 // revoke_and_ack, not on sending commitment_signed, so we add one if have
4895                 // AwaitingRemoteRevoke set, which indicates we sent a commitment_signed but haven't gotten
4896                 // the corresponding revoke_and_ack back yet.
4897                 let is_awaiting_remote_revoke = self.context.channel_state.is_awaiting_remote_revoke();
4898                 if is_awaiting_remote_revoke && !self.is_awaiting_monitor_update() {
4899                         self.mark_awaiting_response();
4900                 }
4901                 let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };
4902
4903                 let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number == 1 {
4904                         // We should never have to worry about MonitorUpdateInProgress resending ChannelReady
4905                         let next_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
4906                         Some(msgs::ChannelReady {
4907                                 channel_id: self.context.channel_id(),
4908                                 next_per_commitment_point,
4909                                 short_channel_id_alias: Some(self.context.outbound_scid_alias),
4910                         })
4911                 } else { None };
4912
4913                 if msg.next_local_commitment_number == next_counterparty_commitment_number {
4914                         if required_revoke.is_some() {
4915                                 log_debug!(logger, "Reconnected channel {} with only lost outbound RAA", &self.context.channel_id());
4916                         } else {
4917                                 log_debug!(logger, "Reconnected channel {} with no loss", &self.context.channel_id());
4918                         }
4919
4920                         Ok(ReestablishResponses {
4921                                 channel_ready, shutdown_msg, announcement_sigs,
4922                                 raa: required_revoke,
4923                                 commitment_update: None,
4924                                 order: self.context.resend_order.clone(),
4925                         })
4926                 } else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
4927                         if required_revoke.is_some() {
4928                                 log_debug!(logger, "Reconnected channel {} with lost outbound RAA and lost remote commitment tx", &self.context.channel_id());
4929                         } else {
4930                                 log_debug!(logger, "Reconnected channel {} with only lost remote commitment tx", &self.context.channel_id());
4931                         }
4932
4933                         if self.context.channel_state.is_monitor_update_in_progress() {
4934                                 self.context.monitor_pending_commitment_signed = true;
4935                                 Ok(ReestablishResponses {
4936                                         channel_ready, shutdown_msg, announcement_sigs,
4937                                         commitment_update: None, raa: None,
4938                                         order: self.context.resend_order.clone(),
4939                                 })
4940                         } else {
4941                                 Ok(ReestablishResponses {
4942                                         channel_ready, shutdown_msg, announcement_sigs,
4943                                         raa: required_revoke,
4944                                         commitment_update: self.get_last_commitment_update_for_send(logger).ok(),
4945                                         order: self.context.resend_order.clone(),
4946                                 })
4947                         }
4948                 } else if msg.next_local_commitment_number < next_counterparty_commitment_number {
4949                         Err(ChannelError::Close(format!(
4950                                 "Peer attempted to reestablish channel with a very old remote commitment transaction: {} (received) vs {} (expected)",
4951                                 msg.next_local_commitment_number,
4952                                 next_counterparty_commitment_number,
4953                         )))
4954                 } else {
4955                         Err(ChannelError::Close(format!(
4956                                 "Peer attempted to reestablish channel with a future remote commitment transaction: {} (received) vs {} (expected)",
4957                                 msg.next_local_commitment_number,
4958                                 next_counterparty_commitment_number,
4959                         )))
4960                 }
4961         }
4962
4963         /// Calculates and returns our minimum and maximum closing transaction fee amounts, in whole
4964         /// satoshis. The amounts remain consistent unless a peer disconnects/reconnects or we restart,
4965         /// at which point they will be recalculated.
4966         fn calculate_closing_fee_limits<F: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>)
4967                 -> (u64, u64)
4968                 where F::Target: FeeEstimator
4969         {
4970                 if let Some((min, max)) = self.context.closing_fee_limits { return (min, max); }
4971
4972                 // Propose a range from our current Background feerate to our Normal feerate plus our
4973                 // force_close_avoidance_max_fee_satoshis.
4974                 // If we fail to come to consensus, we'll have to force-close.
4975                 let mut proposed_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::ChannelCloseMinimum);
4976                 // Use NonAnchorChannelFee because this should be an estimate for a channel close
4977                 // that we don't expect to need fee bumping
4978                 let normal_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
4979                 let mut proposed_max_feerate = if self.context.is_outbound() { normal_feerate } else { u32::max_value() };
4980
4981                 // The spec requires that (when the channel does not have anchors) we only send absolute
4982                 // channel fees no greater than the absolute channel fee on the current commitment
4983                 // transaction. It's unclear *which* commitment transaction this refers to, and there isn't
4984                 // very good reason to apply such a limit in any case. We don't bother doing so, risking
4985                 // some force-closure by old nodes, but we wanted to close the channel anyway.
4986
4987                 if let Some(target_feerate) = self.context.target_closing_feerate_sats_per_kw {
4988                         let min_feerate = if self.context.is_outbound() { target_feerate } else { cmp::min(self.context.feerate_per_kw, target_feerate) };
4989                         proposed_feerate = cmp::max(proposed_feerate, min_feerate);
4990                         proposed_max_feerate = cmp::max(proposed_max_feerate, min_feerate);
4991                 }
4992
4993                 // Note that technically we could end up with a lower minimum fee if one sides' balance is
4994                 // below our dust limit, causing the output to disappear. We don't bother handling this
4995                 // case, however, as this should only happen if a channel is closed before any (material)
4996                 // payments have been made on it. This may cause slight fee overpayment and/or failure to
4997                 // come to consensus with our counterparty on appropriate fees, however it should be a
4998                 // relatively rare case. We can revisit this later, though note that in order to determine
4999                 // if the funders' output is dust we have to know the absolute fee we're going to use.
5000                 let tx_weight = self.get_closing_transaction_weight(Some(&self.get_closing_scriptpubkey()), Some(self.context.counterparty_shutdown_scriptpubkey.as_ref().unwrap()));
5001                 let proposed_total_fee_satoshis = proposed_feerate as u64 * tx_weight / 1000;
5002                 let proposed_max_total_fee_satoshis = if self.context.is_outbound() {
5003                                 // We always add force_close_avoidance_max_fee_satoshis to our normal
5004                                 // feerate-calculated fee, but allow the max to be overridden if we're using a
5005                                 // target feerate-calculated fee.
5006                                 cmp::max(normal_feerate as u64 * tx_weight / 1000 + self.context.config.options.force_close_avoidance_max_fee_satoshis,
5007                                         proposed_max_feerate as u64 * tx_weight / 1000)
5008                         } else {
5009                                 self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 1000
5010                         };
5011
5012                 self.context.closing_fee_limits = Some((proposed_total_fee_satoshis, proposed_max_total_fee_satoshis));
5013                 self.context.closing_fee_limits.clone().unwrap()
5014         }
5015
5016         /// Returns true if we're ready to commence the closing_signed negotiation phase. This is true
5017         /// after both sides have exchanged a `shutdown` message and all HTLCs have been drained. At
5018         /// this point if we're the funder we should send the initial closing_signed, and in any case
5019         /// shutdown should complete within a reasonable timeframe.
5020         fn closing_negotiation_ready(&self) -> bool {
5021                 self.context.closing_negotiation_ready()
5022         }
5023
5024         /// Checks if the closing_signed negotiation is making appropriate progress, possibly returning
5025         /// an Err if no progress is being made and the channel should be force-closed instead.
5026         /// Should be called on a one-minute timer.
5027         pub fn timer_check_closing_negotiation_progress(&mut self) -> Result<(), ChannelError> {
5028                 if self.closing_negotiation_ready() {
5029                         if self.context.closing_signed_in_flight {
5030                                 return Err(ChannelError::Close("closing_signed negotiation failed to finish within two timer ticks".to_owned()));
5031                         } else {
5032                                 self.context.closing_signed_in_flight = true;
5033                         }
5034                 }
5035                 Ok(())
5036         }
5037
5038         pub fn maybe_propose_closing_signed<F: Deref, L: Deref>(
5039                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
5040                 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>, Option<ShutdownResult>), ChannelError>
5041                 where F::Target: FeeEstimator, L::Target: Logger
5042         {
5043                 // If we're waiting on a monitor persistence, that implies we're also waiting to send some
5044                 // message to our counterparty (probably a `revoke_and_ack`). In such a case, we shouldn't
5045                 // initiate `closing_signed` negotiation until we're clear of all pending messages. Note
5046                 // that closing_negotiation_ready checks this case (as well as a few others).
5047                 if self.context.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
5048                         return Ok((None, None, None));
5049                 }
5050
5051                 if !self.context.is_outbound() {
5052                         if let Some(msg) = &self.context.pending_counterparty_closing_signed.take() {
5053                                 return self.closing_signed(fee_estimator, &msg);
5054                         }
5055                         return Ok((None, None, None));
5056                 }
5057
5058                 // If we're waiting on a counterparty `commitment_signed` to clear some updates from our
5059                 // local commitment transaction, we can't yet initiate `closing_signed` negotiation.
5060                 if self.context.expecting_peer_commitment_signed {
5061                         return Ok((None, None, None));
5062                 }
5063
5064                 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
5065
5066                 assert!(self.context.shutdown_scriptpubkey.is_some());
5067                 let (closing_tx, total_fee_satoshis) = self.build_closing_transaction(our_min_fee, false);
5068                 log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
5069                         our_min_fee, our_max_fee, total_fee_satoshis);
5070
5071                 match &self.context.holder_signer {
5072                         ChannelSignerType::Ecdsa(ecdsa) => {
5073                                 let sig = ecdsa
5074                                         .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
5075                                         .map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
5076
5077                                 self.context.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
5078                                 Ok((Some(msgs::ClosingSigned {
5079                                         channel_id: self.context.channel_id,
5080                                         fee_satoshis: total_fee_satoshis,
5081                                         signature: sig,
5082                                         fee_range: Some(msgs::ClosingSignedFeeRange {
5083                                                 min_fee_satoshis: our_min_fee,
5084                                                 max_fee_satoshis: our_max_fee,
5085                                         }),
5086                                 }), None, None))
5087                         },
5088                         // TODO (taproot|arik)
5089                         #[cfg(taproot)]
5090                         _ => todo!()
5091                 }
5092         }
5093
5094         // Marks a channel as waiting for a response from the counterparty. If it's not received
5095         // [`DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`] after sending our own to them, then we'll attempt
5096         // a reconnection.
5097         fn mark_awaiting_response(&mut self) {
5098                 self.context.sent_message_awaiting_response = Some(0);
5099         }
5100
5101         /// Determines whether we should disconnect the counterparty due to not receiving a response
5102         /// within our expected timeframe.
5103         ///
5104         /// This should be called on every [`super::channelmanager::ChannelManager::timer_tick_occurred`].
5105         pub fn should_disconnect_peer_awaiting_response(&mut self) -> bool {
5106                 let ticks_elapsed = if let Some(ticks_elapsed) = self.context.sent_message_awaiting_response.as_mut() {
5107                         ticks_elapsed
5108                 } else {
5109                         // Don't disconnect when we're not waiting on a response.
5110                         return false;
5111                 };
5112                 *ticks_elapsed += 1;
5113                 *ticks_elapsed >= DISCONNECT_PEER_AWAITING_RESPONSE_TICKS
5114         }
5115
5116         pub fn shutdown(
5117                 &mut self, signer_provider: &SP, their_features: &InitFeatures, msg: &msgs::Shutdown
5118         ) -> Result<(Option<msgs::Shutdown>, Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), ChannelError>
5119         {
5120                 if self.context.channel_state.is_peer_disconnected() {
5121                         return Err(ChannelError::Close("Peer sent shutdown when we needed a channel_reestablish".to_owned()));
5122                 }
5123                 if self.context.channel_state.is_pre_funded_state() {
5124                         // Spec says we should fail the connection, not the channel, but that's nonsense, there
5125                         // are plenty of reasons you may want to fail a channel pre-funding, and spec says you
5126                         // can do that via error message without getting a connection fail anyway...
5127                         return Err(ChannelError::Close("Peer sent shutdown pre-funding generation".to_owned()));
5128                 }
5129                 for htlc in self.context.pending_inbound_htlcs.iter() {
5130                         if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
5131                                 return Err(ChannelError::Close("Got shutdown with remote pending HTLCs".to_owned()));
5132                         }
5133                 }
5134                 assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
5135
5136                 if !script::is_bolt2_compliant(&msg.scriptpubkey, their_features) {
5137                         return Err(ChannelError::Warn(format!("Got a nonstandard scriptpubkey ({}) from remote peer", msg.scriptpubkey.to_hex_string())));
5138                 }
5139
5140                 if self.context.counterparty_shutdown_scriptpubkey.is_some() {
5141                         if Some(&msg.scriptpubkey) != self.context.counterparty_shutdown_scriptpubkey.as_ref() {
5142                                 return Err(ChannelError::Warn(format!("Got shutdown request with a scriptpubkey ({}) which did not match their previous scriptpubkey.", msg.scriptpubkey.to_hex_string())));
5143                         }
5144                 } else {
5145                         self.context.counterparty_shutdown_scriptpubkey = Some(msg.scriptpubkey.clone());
5146                 }
5147
5148                 // If we have any LocalAnnounced updates we'll probably just get back an update_fail_htlc
5149                 // immediately after the commitment dance, but we can send a Shutdown because we won't send
5150                 // any further commitment updates after we set LocalShutdownSent.
5151                 let send_shutdown = !self.context.channel_state.is_local_shutdown_sent();
5152
5153                 let update_shutdown_script = match self.context.shutdown_scriptpubkey {
5154                         Some(_) => false,
5155                         None => {
5156                                 assert!(send_shutdown);
5157                                 let shutdown_scriptpubkey = match signer_provider.get_shutdown_scriptpubkey() {
5158                                         Ok(scriptpubkey) => scriptpubkey,
5159                                         Err(_) => return Err(ChannelError::Close("Failed to get shutdown scriptpubkey".to_owned())),
5160                                 };
5161                                 if !shutdown_scriptpubkey.is_compatible(their_features) {
5162                                         return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
5163                                 }
5164                                 self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
5165                                 true
5166                         },
5167                 };
5168
5169                 // From here on out, we may not fail!
5170
5171                 self.context.channel_state.set_remote_shutdown_sent();
5172                 self.context.update_time_counter += 1;
5173
5174                 let monitor_update = if update_shutdown_script {
5175                         self.context.latest_monitor_update_id += 1;
5176                         let monitor_update = ChannelMonitorUpdate {
5177                                 update_id: self.context.latest_monitor_update_id,
5178                                 counterparty_node_id: Some(self.context.counterparty_node_id),
5179                                 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
5180                                         scriptpubkey: self.get_closing_scriptpubkey(),
5181                                 }],
5182                                 channel_id: Some(self.context.channel_id()),
5183                         };
5184                         self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
5185                         self.push_ret_blockable_mon_update(monitor_update)
5186                 } else { None };
5187                 let shutdown = if send_shutdown {
5188                         Some(msgs::Shutdown {
5189                                 channel_id: self.context.channel_id,
5190                                 scriptpubkey: self.get_closing_scriptpubkey(),
5191                         })
5192                 } else { None };
5193
5194                 // We can't send our shutdown until we've committed all of our pending HTLCs, but the
5195                 // remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding
5196                 // cell HTLCs and return them to fail the payment.
5197                 self.context.holding_cell_update_fee = None;
5198                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
5199                 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
5200                         match htlc_update {
5201                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
5202                                         dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
5203                                         false
5204                                 },
5205                                 _ => true
5206                         }
5207                 });
5208
5209                 self.context.channel_state.set_local_shutdown_sent();
5210                 self.context.update_time_counter += 1;
5211
5212                 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
5213         }
5214
5215         fn build_signed_closing_transaction(&self, closing_tx: &ClosingTransaction, counterparty_sig: &Signature, sig: &Signature) -> Transaction {
5216                 let mut tx = closing_tx.trust().built_transaction().clone();
5217
5218                 tx.input[0].witness.push(Vec::new()); // First is the multisig dummy
5219
5220                 let funding_key = self.context.get_holder_pubkeys().funding_pubkey.serialize();
5221                 let counterparty_funding_key = self.context.counterparty_funding_pubkey().serialize();
5222                 let mut holder_sig = sig.serialize_der().to_vec();
5223                 holder_sig.push(EcdsaSighashType::All as u8);
5224                 let mut cp_sig = counterparty_sig.serialize_der().to_vec();
5225                 cp_sig.push(EcdsaSighashType::All as u8);
5226                 if funding_key[..] < counterparty_funding_key[..] {
5227                         tx.input[0].witness.push(holder_sig);
5228                         tx.input[0].witness.push(cp_sig);
5229                 } else {
5230                         tx.input[0].witness.push(cp_sig);
5231                         tx.input[0].witness.push(holder_sig);
5232                 }
5233
5234                 tx.input[0].witness.push(self.context.get_funding_redeemscript().into_bytes());
5235                 tx
5236         }
5237
5238         pub fn closing_signed<F: Deref>(
5239                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::ClosingSigned)
5240                 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>, Option<ShutdownResult>), ChannelError>
5241                 where F::Target: FeeEstimator
5242         {
5243                 if !self.context.channel_state.is_both_sides_shutdown() {
5244                         return Err(ChannelError::Close("Remote end sent us a closing_signed before both sides provided a shutdown".to_owned()));
5245                 }
5246                 if self.context.channel_state.is_peer_disconnected() {
5247                         return Err(ChannelError::Close("Peer sent closing_signed when we needed a channel_reestablish".to_owned()));
5248                 }
5249                 if !self.context.pending_inbound_htlcs.is_empty() || !self.context.pending_outbound_htlcs.is_empty() {
5250                         return Err(ChannelError::Close("Remote end sent us a closing_signed while there were still pending HTLCs".to_owned()));
5251                 }
5252                 if msg.fee_satoshis > TOTAL_BITCOIN_SUPPLY_SATOSHIS { // this is required to stop potential overflow in build_closing_transaction
5253                         return Err(ChannelError::Close("Remote tried to send us a closing tx with > 21 million BTC fee".to_owned()));
5254                 }
5255
5256                 if self.context.is_outbound() && self.context.last_sent_closing_fee.is_none() {
5257                         return Err(ChannelError::Close("Remote tried to send a closing_signed when we were supposed to propose the first one".to_owned()));
5258                 }
5259
5260                 if self.context.channel_state.is_monitor_update_in_progress() {
5261                         self.context.pending_counterparty_closing_signed = Some(msg.clone());
5262                         return Ok((None, None, None));
5263                 }
5264
5265                 let funding_redeemscript = self.context.get_funding_redeemscript();
5266                 let (mut closing_tx, used_total_fee) = self.build_closing_transaction(msg.fee_satoshis, false);
5267                 if used_total_fee != msg.fee_satoshis {
5268                         return Err(ChannelError::Close(format!("Remote sent us a closing_signed with a fee other than the value they can claim. Fee in message: {}. Actual closing tx fee: {}", msg.fee_satoshis, used_total_fee)));
5269                 }
5270                 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
5271
5272                 match self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.get_counterparty_pubkeys().funding_pubkey) {
5273                         Ok(_) => {},
5274                         Err(_e) => {
5275                                 // The remote end may have decided to revoke their output due to inconsistent dust
5276                                 // limits, so check for that case by re-checking the signature here.
5277                                 closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
5278                                 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
5279                                 secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, self.context.counterparty_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
5280                         },
5281                 };
5282
5283                 for outp in closing_tx.trust().built_transaction().output.iter() {
5284                         if !outp.script_pubkey.is_witness_program() && outp.value < MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS {
5285                                 return Err(ChannelError::Close("Remote sent us a closing_signed with a dust output. Always use segwit closing scripts!".to_owned()));
5286                         }
5287                 }
5288
5289                 let closure_reason = if self.initiated_shutdown() {
5290                         ClosureReason::LocallyInitiatedCooperativeClosure
5291                 } else {
5292                         ClosureReason::CounterpartyInitiatedCooperativeClosure
5293                 };
5294
5295                 assert!(self.context.shutdown_scriptpubkey.is_some());
5296                 if let Some((last_fee, sig)) = self.context.last_sent_closing_fee {
5297                         if last_fee == msg.fee_satoshis {
5298                                 let shutdown_result = ShutdownResult {
5299                                         closure_reason,
5300                                         monitor_update: None,
5301                                         dropped_outbound_htlcs: Vec::new(),
5302                                         unbroadcasted_batch_funding_txid: self.context.unbroadcasted_batch_funding_txid(),
5303                                         channel_id: self.context.channel_id,
5304                                         user_channel_id: self.context.user_id,
5305                                         channel_capacity_satoshis: self.context.channel_value_satoshis,
5306                                         counterparty_node_id: self.context.counterparty_node_id,
5307                                         unbroadcasted_funding_tx: self.context.unbroadcasted_funding(),
5308                                         channel_funding_txo: self.context.get_funding_txo(),
5309                                 };
5310                                 let tx = self.build_signed_closing_transaction(&mut closing_tx, &msg.signature, &sig);
5311                                 self.context.channel_state = ChannelState::ShutdownComplete;
5312                                 self.context.update_time_counter += 1;
5313                                 return Ok((None, Some(tx), Some(shutdown_result)));
5314                         }
5315                 }
5316
5317                 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
5318
5319                 macro_rules! propose_fee {
5320                         ($new_fee: expr) => {
5321                                 let (closing_tx, used_fee) = if $new_fee == msg.fee_satoshis {
5322                                         (closing_tx, $new_fee)
5323                                 } else {
5324                                         self.build_closing_transaction($new_fee, false)
5325                                 };
5326
5327                                 return match &self.context.holder_signer {
5328                                         ChannelSignerType::Ecdsa(ecdsa) => {
5329                                                 let sig = ecdsa
5330                                                         .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
5331                                                         .map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
5332                                                 let (signed_tx, shutdown_result) = if $new_fee == msg.fee_satoshis {
5333                                                         let shutdown_result = ShutdownResult {
5334                                                                 closure_reason,
5335                                                                 monitor_update: None,
5336                                                                 dropped_outbound_htlcs: Vec::new(),
5337                                                                 unbroadcasted_batch_funding_txid: self.context.unbroadcasted_batch_funding_txid(),
5338                                                                 channel_id: self.context.channel_id,
5339                                                                 user_channel_id: self.context.user_id,
5340                                                                 channel_capacity_satoshis: self.context.channel_value_satoshis,
5341                                                                 counterparty_node_id: self.context.counterparty_node_id,
5342                                                                 unbroadcasted_funding_tx: self.context.unbroadcasted_funding(),
5343                                                                 channel_funding_txo: self.context.get_funding_txo(),
5344                                                         };
5345                                                         self.context.channel_state = ChannelState::ShutdownComplete;
5346                                                         self.context.update_time_counter += 1;
5347                                                         let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
5348                                                         (Some(tx), Some(shutdown_result))
5349                                                 } else {
5350                                                         (None, None)
5351                                                 };
5352
5353                                                 self.context.last_sent_closing_fee = Some((used_fee, sig.clone()));
5354                                                 Ok((Some(msgs::ClosingSigned {
5355                                                         channel_id: self.context.channel_id,
5356                                                         fee_satoshis: used_fee,
5357                                                         signature: sig,
5358                                                         fee_range: Some(msgs::ClosingSignedFeeRange {
5359                                                                 min_fee_satoshis: our_min_fee,
5360                                                                 max_fee_satoshis: our_max_fee,
5361                                                         }),
5362                                                 }), signed_tx, shutdown_result))
5363                                         },
5364                                         // TODO (taproot|arik)
5365                                         #[cfg(taproot)]
5366                                         _ => todo!()
5367                                 }
5368                         }
5369                 }
5370
5371                 if let Some(msgs::ClosingSignedFeeRange { min_fee_satoshis, max_fee_satoshis }) = msg.fee_range {
5372                         if msg.fee_satoshis < min_fee_satoshis || msg.fee_satoshis > max_fee_satoshis {
5373                                 return Err(ChannelError::Close(format!("Peer sent a bogus closing_signed - suggested fee of {} sat was not in their desired range of {} sat - {} sat", msg.fee_satoshis, min_fee_satoshis, max_fee_satoshis)));
5374                         }
5375                         if max_fee_satoshis < our_min_fee {
5376                                 return Err(ChannelError::Warn(format!("Unable to come to consensus about closing feerate, remote's max fee ({} sat) was smaller than our min fee ({} sat)", max_fee_satoshis, our_min_fee)));
5377                         }
5378                         if min_fee_satoshis > our_max_fee {
5379                                 return Err(ChannelError::Warn(format!("Unable to come to consensus about closing feerate, remote's min fee ({} sat) was greater than our max fee ({} sat)", min_fee_satoshis, our_max_fee)));
5380                         }
5381
5382                         if !self.context.is_outbound() {
5383                                 // They have to pay, so pick the highest fee in the overlapping range.
5384                                 // We should never set an upper bound aside from their full balance
5385                                 debug_assert_eq!(our_max_fee, self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 1000);
5386                                 propose_fee!(cmp::min(max_fee_satoshis, our_max_fee));
5387                         } else {
5388                                 if msg.fee_satoshis < our_min_fee || msg.fee_satoshis > our_max_fee {
5389                                         return Err(ChannelError::Close(format!("Peer sent a bogus closing_signed - suggested fee of {} sat was not in our desired range of {} sat - {} sat after we informed them of our range.",
5390                                                 msg.fee_satoshis, our_min_fee, our_max_fee)));
5391                                 }
5392                                 // The proposed fee is in our acceptable range, accept it and broadcast!
5393                                 propose_fee!(msg.fee_satoshis);
5394                         }
5395                 } else {
5396                         // Old fee style negotiation. We don't bother to enforce whether they are complying
5397                         // with the "making progress" requirements, we just comply and hope for the best.
5398                         if let Some((last_fee, _)) = self.context.last_sent_closing_fee {
5399                                 if msg.fee_satoshis > last_fee {
5400                                         if msg.fee_satoshis < our_max_fee {
5401                                                 propose_fee!(msg.fee_satoshis);
5402                                         } else if last_fee < our_max_fee {
5403                                                 propose_fee!(our_max_fee);
5404                                         } else {
5405                                                 return Err(ChannelError::Close(format!("Unable to come to consensus about closing feerate, remote wants something ({} sat) higher than our max fee ({} sat)", msg.fee_satoshis, our_max_fee)));
5406                                         }
5407                                 } else {
5408                                         if msg.fee_satoshis > our_min_fee {
5409                                                 propose_fee!(msg.fee_satoshis);
5410                                         } else if last_fee > our_min_fee {
5411                                                 propose_fee!(our_min_fee);
5412                                         } else {
5413                                                 return Err(ChannelError::Close(format!("Unable to come to consensus about closing feerate, remote wants something ({} sat) lower than our min fee ({} sat)", msg.fee_satoshis, our_min_fee)));
5414                                         }
5415                                 }
5416                         } else {
5417                                 if msg.fee_satoshis < our_min_fee {
5418                                         propose_fee!(our_min_fee);
5419                                 } else if msg.fee_satoshis > our_max_fee {
5420                                         propose_fee!(our_max_fee);
5421                                 } else {
5422                                         propose_fee!(msg.fee_satoshis);
5423                                 }
5424                         }
5425                 }
5426         }
5427
5428         fn internal_htlc_satisfies_config(
5429                 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32, config: &ChannelConfig,
5430         ) -> Result<(), (&'static str, u16)> {
5431                 let fee = amt_to_forward.checked_mul(config.forwarding_fee_proportional_millionths as u64)
5432                         .and_then(|prop_fee| (prop_fee / 1000000).checked_add(config.forwarding_fee_base_msat as u64));
5433                 if fee.is_none() || htlc.amount_msat < fee.unwrap() ||
5434                         (htlc.amount_msat - fee.unwrap()) < amt_to_forward {
5435                         return Err((
5436                                 "Prior hop has deviated from specified fees parameters or origin node has obsolete ones",
5437                                 0x1000 | 12, // fee_insufficient
5438                         ));
5439                 }
5440                 if (htlc.cltv_expiry as u64) < outgoing_cltv_value as u64 + config.cltv_expiry_delta as u64 {
5441                         return Err((
5442                                 "Forwarding node has tampered with the intended HTLC values or origin node has an obsolete cltv_expiry_delta",
5443                                 0x1000 | 13, // incorrect_cltv_expiry
5444                         ));
5445                 }
5446                 Ok(())
5447         }
5448
5449         /// Determines whether the parameters of an incoming HTLC to be forwarded satisfy the channel's
5450         /// [`ChannelConfig`]. This first looks at the channel's current [`ChannelConfig`], and if
5451         /// unsuccessful, falls back to the previous one if one exists.
5452         pub fn htlc_satisfies_config(
5453                 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32,
5454         ) -> Result<(), (&'static str, u16)> {
5455                 self.internal_htlc_satisfies_config(&htlc, amt_to_forward, outgoing_cltv_value, &self.context.config())
5456                         .or_else(|err| {
5457                                 if let Some(prev_config) = self.context.prev_config() {
5458                                         self.internal_htlc_satisfies_config(htlc, amt_to_forward, outgoing_cltv_value, &prev_config)
5459                                 } else {
5460                                         Err(err)
5461                                 }
5462                         })
5463         }
5464
5465         pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
5466                 self.context.cur_holder_commitment_transaction_number + 1
5467         }
5468
5469         pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
5470                 self.context.cur_counterparty_commitment_transaction_number + 1 - if self.context.channel_state.is_awaiting_remote_revoke() { 1 } else { 0 }
5471         }
5472
5473         pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
5474                 self.context.cur_counterparty_commitment_transaction_number + 2
5475         }
5476
5477         #[cfg(test)]
5478         pub fn get_signer(&self) -> &ChannelSignerType<SP> {
5479                 &self.context.holder_signer
5480         }
5481
5482         #[cfg(test)]
5483         pub fn get_value_stat(&self) -> ChannelValueStat {
5484                 ChannelValueStat {
5485                         value_to_self_msat: self.context.value_to_self_msat,
5486                         channel_value_msat: self.context.channel_value_satoshis * 1000,
5487                         channel_reserve_msat: self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000,
5488                         pending_outbound_htlcs_amount_msat: self.context.pending_outbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
5489                         pending_inbound_htlcs_amount_msat: self.context.pending_inbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
5490                         holding_cell_outbound_amount_msat: {
5491                                 let mut res = 0;
5492                                 for h in self.context.holding_cell_htlc_updates.iter() {
5493                                         match h {
5494                                                 &HTLCUpdateAwaitingACK::AddHTLC{amount_msat, .. } => {
5495                                                         res += amount_msat;
5496                                                 }
5497                                                 _ => {}
5498                                         }
5499                                 }
5500                                 res
5501                         },
5502                         counterparty_max_htlc_value_in_flight_msat: self.context.counterparty_max_htlc_value_in_flight_msat,
5503                         counterparty_dust_limit_msat: self.context.counterparty_dust_limit_satoshis * 1000,
5504                 }
5505         }
5506
5507         /// Returns true if this channel has been marked as awaiting a monitor update to move forward.
5508         /// Allowed in any state (including after shutdown)
5509         pub fn is_awaiting_monitor_update(&self) -> bool {
5510                 self.context.channel_state.is_monitor_update_in_progress()
5511         }
5512
5513         /// Gets the latest [`ChannelMonitorUpdate`] ID which has been released and is in-flight.
5514         pub fn get_latest_unblocked_monitor_update_id(&self) -> u64 {
5515                 if self.context.blocked_monitor_updates.is_empty() { return self.context.get_latest_monitor_update_id(); }
5516                 self.context.blocked_monitor_updates[0].update.update_id - 1
5517         }
5518
5519         /// Returns the next blocked monitor update, if one exists, and a bool which indicates a
5520         /// further blocked monitor update exists after the next.
5521         pub fn unblock_next_blocked_monitor_update(&mut self) -> Option<(ChannelMonitorUpdate, bool)> {
5522                 if self.context.blocked_monitor_updates.is_empty() { return None; }
5523                 Some((self.context.blocked_monitor_updates.remove(0).update,
5524                         !self.context.blocked_monitor_updates.is_empty()))
5525         }
5526
5527         /// Pushes a new monitor update into our monitor update queue, returning it if it should be
5528         /// immediately given to the user for persisting or `None` if it should be held as blocked.
5529         fn push_ret_blockable_mon_update(&mut self, update: ChannelMonitorUpdate)
5530         -> Option<ChannelMonitorUpdate> {
5531                 let release_monitor = self.context.blocked_monitor_updates.is_empty();
5532                 if !release_monitor {
5533                         self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
5534                                 update,
5535                         });
5536                         None
5537                 } else {
5538                         Some(update)
5539                 }
5540         }
5541
5542         pub fn blocked_monitor_updates_pending(&self) -> usize {
5543                 self.context.blocked_monitor_updates.len()
5544         }
5545
5546         /// Returns true if the channel is awaiting the persistence of the initial ChannelMonitor.
5547         /// If the channel is outbound, this implies we have not yet broadcasted the funding
5548         /// transaction. If the channel is inbound, this implies simply that the channel has not
5549         /// advanced state.
5550         pub fn is_awaiting_initial_mon_persist(&self) -> bool {
5551                 if !self.is_awaiting_monitor_update() { return false; }
5552                 if matches!(
5553                         self.context.channel_state, ChannelState::AwaitingChannelReady(flags)
5554                         if flags.clone().clear(AwaitingChannelReadyFlags::THEIR_CHANNEL_READY | FundedStateFlags::PEER_DISCONNECTED | FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS | AwaitingChannelReadyFlags::WAITING_FOR_BATCH).is_empty()
5555                 ) {
5556                         // If we're not a 0conf channel, we'll be waiting on a monitor update with only
5557                         // AwaitingChannelReady set, though our peer could have sent their channel_ready.
5558                         debug_assert!(self.context.minimum_depth.unwrap_or(1) > 0);
5559                         return true;
5560                 }
5561                 if self.context.cur_holder_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 &&
5562                         self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
5563                         // If we're a 0-conf channel, we'll move beyond AwaitingChannelReady immediately even while
5564                         // waiting for the initial monitor persistence. Thus, we check if our commitment
5565                         // transaction numbers have both been iterated only exactly once (for the
5566                         // funding_signed), and we're awaiting monitor update.
5567                         //
5568                         // If we got here, we shouldn't have yet broadcasted the funding transaction (as the
5569                         // only way to get an awaiting-monitor-update state during initial funding is if the
5570                         // initial monitor persistence is still pending).
5571                         //
5572                         // Because deciding we're awaiting initial broadcast spuriously could result in
5573                         // funds-loss (as we don't have a monitor, but have the funding transaction confirmed),
5574                         // we hard-assert here, even in production builds.
5575                         if self.context.is_outbound() { assert!(self.context.funding_transaction.is_some()); }
5576                         assert!(self.context.monitor_pending_channel_ready);
5577                         assert_eq!(self.context.latest_monitor_update_id, 0);
5578                         return true;
5579                 }
5580                 false
5581         }
5582
5583         /// Returns true if our channel_ready has been sent
5584         pub fn is_our_channel_ready(&self) -> bool {
5585                 matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(flags) if flags.is_set(AwaitingChannelReadyFlags::OUR_CHANNEL_READY)) ||
5586                         matches!(self.context.channel_state, ChannelState::ChannelReady(_))
5587         }
5588
5589         /// Returns true if our peer has either initiated or agreed to shut down the channel.
5590         pub fn received_shutdown(&self) -> bool {
5591                 self.context.channel_state.is_remote_shutdown_sent()
5592         }
5593
5594         /// Returns true if we either initiated or agreed to shut down the channel.
5595         pub fn sent_shutdown(&self) -> bool {
5596                 self.context.channel_state.is_local_shutdown_sent()
5597         }
5598
5599         /// Returns true if we initiated to shut down the channel.
5600         pub fn initiated_shutdown(&self) -> bool {
5601                 self.context.local_initiated_shutdown.is_some()
5602         }
5603
5604         /// Returns true if this channel is fully shut down. True here implies that no further actions
5605         /// may/will be taken on this channel, and thus this object should be freed. Any future changes
5606         /// will be handled appropriately by the chain monitor.
5607         pub fn is_shutdown(&self) -> bool {
5608                 matches!(self.context.channel_state, ChannelState::ShutdownComplete)
5609         }
5610
5611         pub fn channel_update_status(&self) -> ChannelUpdateStatus {
5612                 self.context.channel_update_status
5613         }
5614
5615         pub fn set_channel_update_status(&mut self, status: ChannelUpdateStatus) {
5616                 self.context.update_time_counter += 1;
5617                 self.context.channel_update_status = status;
5618         }
5619
5620         fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
5621                 // Called:
5622                 //  * always when a new block/transactions are confirmed with the new height
5623                 //  * when funding is signed with a height of 0
5624                 if self.context.funding_tx_confirmation_height == 0 && self.context.minimum_depth != Some(0) {
5625                         return None;
5626                 }
5627
5628                 let funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
5629                 if funding_tx_confirmations <= 0 {
5630                         self.context.funding_tx_confirmation_height = 0;
5631                 }
5632
5633                 if funding_tx_confirmations < self.context.minimum_depth.unwrap_or(0) as i64 {
5634                         return None;
5635                 }
5636
5637                 // If we're still pending the signature on a funding transaction, then we're not ready to send a
5638                 // channel_ready yet.
5639                 if self.context.signer_pending_funding {
5640                         return None;
5641                 }
5642
5643                 // Note that we don't include ChannelState::WaitingForBatch as we don't want to send
5644                 // channel_ready until the entire batch is ready.
5645                 let need_commitment_update = if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()).is_empty()) {
5646                         self.context.channel_state.set_our_channel_ready();
5647                         true
5648                 } else if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()) == AwaitingChannelReadyFlags::THEIR_CHANNEL_READY) {
5649                         self.context.channel_state = ChannelState::ChannelReady(self.context.channel_state.with_funded_state_flags_mask().into());
5650                         self.context.update_time_counter += 1;
5651                         true
5652                 } else if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()) == AwaitingChannelReadyFlags::OUR_CHANNEL_READY) {
5653                         // We got a reorg but not enough to trigger a force close, just ignore.
5654                         false
5655                 } else {
5656                         if self.context.funding_tx_confirmation_height != 0 &&
5657                                 self.context.channel_state < ChannelState::ChannelReady(ChannelReadyFlags::new())
5658                         {
5659                                 // We should never see a funding transaction on-chain until we've received
5660                                 // funding_signed (if we're an outbound channel), or seen funding_generated (if we're
5661                                 // an inbound channel - before that we have no known funding TXID). The fuzzer,
5662                                 // however, may do this and we shouldn't treat it as a bug.
5663                                 #[cfg(not(fuzzing))]
5664                                 panic!("Started confirming a channel in a state pre-AwaitingChannelReady: {}.\n\
5665                                         Do NOT broadcast a funding transaction manually - let LDK do it for you!",
5666                                         self.context.channel_state.to_u32());
5667                         }
5668                         // We got a reorg but not enough to trigger a force close, just ignore.
5669                         false
5670                 };
5671
5672                 if need_commitment_update {
5673                         if !self.context.channel_state.is_monitor_update_in_progress() {
5674                                 if !self.context.channel_state.is_peer_disconnected() {
5675                                         let next_per_commitment_point =
5676                                                 self.context.holder_signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.context.secp_ctx);
5677                                         return Some(msgs::ChannelReady {
5678                                                 channel_id: self.context.channel_id,
5679                                                 next_per_commitment_point,
5680                                                 short_channel_id_alias: Some(self.context.outbound_scid_alias),
5681                                         });
5682                                 }
5683                         } else {
5684                                 self.context.monitor_pending_channel_ready = true;
5685                         }
5686                 }
5687                 None
5688         }
5689
5690         /// When a transaction is confirmed, we check whether it is or spends the funding transaction
5691         /// In the first case, we store the confirmation height and calculating the short channel id.
5692         /// In the second, we simply return an Err indicating we need to be force-closed now.
5693         pub fn transactions_confirmed<NS: Deref, L: Deref>(
5694                 &mut self, block_hash: &BlockHash, height: u32, txdata: &TransactionData,
5695                 chain_hash: ChainHash, node_signer: &NS, user_config: &UserConfig, logger: &L
5696         ) -> Result<(Option<msgs::ChannelReady>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5697         where
5698                 NS::Target: NodeSigner,
5699                 L::Target: Logger
5700         {
5701                 let mut msgs = (None, None);
5702                 if let Some(funding_txo) = self.context.get_funding_txo() {
5703                         for &(index_in_block, tx) in txdata.iter() {
5704                                 // Check if the transaction is the expected funding transaction, and if it is,
5705                                 // check that it pays the right amount to the right script.
5706                                 if self.context.funding_tx_confirmation_height == 0 {
5707                                         if tx.txid() == funding_txo.txid {
5708                                                 let txo_idx = funding_txo.index as usize;
5709                                                 if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.context.get_funding_redeemscript().to_v0_p2wsh() ||
5710                                                                 tx.output[txo_idx].value != self.context.channel_value_satoshis {
5711                                                         if self.context.is_outbound() {
5712                                                                 // If we generated the funding transaction and it doesn't match what it
5713                                                                 // should, the client is really broken and we should just panic and
5714                                                                 // tell them off. That said, because hash collisions happen with high
5715                                                                 // probability in fuzzing mode, if we're fuzzing we just close the
5716                                                                 // channel and move on.
5717                                                                 #[cfg(not(fuzzing))]
5718                                                                 panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
5719                                                         }
5720                                                         self.context.update_time_counter += 1;
5721                                                         let err_reason = "funding tx had wrong script/value or output index";
5722                                                         return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
5723                                                 } else {
5724                                                         if self.context.is_outbound() {
5725                                                                 if !tx.is_coin_base() {
5726                                                                         for input in tx.input.iter() {
5727                                                                                 if input.witness.is_empty() {
5728                                                                                         // We generated a malleable funding transaction, implying we've
5729                                                                                         // just exposed ourselves to funds loss to our counterparty.
5730                                                                                         #[cfg(not(fuzzing))]
5731                                                                                         panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
5732                                                                                 }
5733                                                                         }
5734                                                                 }
5735                                                         }
5736                                                         self.context.funding_tx_confirmation_height = height;
5737                                                         self.context.funding_tx_confirmed_in = Some(*block_hash);
5738                                                         self.context.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
5739                                                                 Ok(scid) => Some(scid),
5740                                                                 Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
5741                                                         }
5742                                                 }
5743                                                 // If this is a coinbase transaction and not a 0-conf channel
5744                                                 // we should update our min_depth to 100 to handle coinbase maturity
5745                                                 if tx.is_coin_base() &&
5746                                                         self.context.minimum_depth.unwrap_or(0) > 0 &&
5747                                                         self.context.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
5748                                                         self.context.minimum_depth = Some(COINBASE_MATURITY);
5749                                                 }
5750                                         }
5751                                         // If we allow 1-conf funding, we may need to check for channel_ready here and
5752                                         // send it immediately instead of waiting for a best_block_updated call (which
5753                                         // may have already happened for this block).
5754                                         if let Some(channel_ready) = self.check_get_channel_ready(height) {
5755                                                 log_info!(logger, "Sending a channel_ready to our peer for channel {}", &self.context.channel_id);
5756                                                 let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger);
5757                                                 msgs = (Some(channel_ready), announcement_sigs);
5758                                         }
5759                                 }
5760                                 for inp in tx.input.iter() {
5761                                         if inp.previous_output == funding_txo.into_bitcoin_outpoint() {
5762                                                 log_info!(logger, "Detected channel-closing tx {} spending {}:{}, closing channel {}", tx.txid(), inp.previous_output.txid, inp.previous_output.vout, &self.context.channel_id());
5763                                                 return Err(ClosureReason::CommitmentTxConfirmed);
5764                                         }
5765                                 }
5766                         }
5767                 }
5768                 Ok(msgs)
5769         }
5770
5771         /// When a new block is connected, we check the height of the block against outbound holding
5772         /// cell HTLCs in case we need to give up on them prematurely and time them out. Everything
5773         /// else (e.g. commitment transaction broadcasts, HTLC transaction broadcasting, etc) is
5774         /// handled by the ChannelMonitor.
5775         ///
5776         /// If we return Err, the channel may have been closed, at which point the standard
5777         /// requirements apply - no calls may be made except those explicitly stated to be allowed
5778         /// post-shutdown.
5779         ///
5780         /// May return some HTLCs (and their payment_hash) which have timed out and should be failed
5781         /// back.
5782         pub fn best_block_updated<NS: Deref, L: Deref>(
5783                 &mut self, height: u32, highest_header_time: u32, chain_hash: ChainHash,
5784                 node_signer: &NS, user_config: &UserConfig, logger: &L
5785         ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5786         where
5787                 NS::Target: NodeSigner,
5788                 L::Target: Logger
5789         {
5790                 self.do_best_block_updated(height, highest_header_time, Some((chain_hash, node_signer, user_config)), logger)
5791         }
5792
5793         fn do_best_block_updated<NS: Deref, L: Deref>(
5794                 &mut self, height: u32, highest_header_time: u32,
5795                 chain_node_signer: Option<(ChainHash, &NS, &UserConfig)>, logger: &L
5796         ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5797         where
5798                 NS::Target: NodeSigner,
5799                 L::Target: Logger
5800         {
5801                 let mut timed_out_htlcs = Vec::new();
5802                 // This mirrors the check in ChannelManager::decode_update_add_htlc_onion, refusing to
5803                 // forward an HTLC when our counterparty should almost certainly just fail it for expiring
5804                 // ~now.
5805                 let unforwarded_htlc_cltv_limit = height + LATENCY_GRACE_PERIOD_BLOCKS;
5806                 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
5807                         match htlc_update {
5808                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, ref cltv_expiry, .. } => {
5809                                         if *cltv_expiry <= unforwarded_htlc_cltv_limit {
5810                                                 timed_out_htlcs.push((source.clone(), payment_hash.clone()));
5811                                                 false
5812                                         } else { true }
5813                                 },
5814                                 _ => true
5815                         }
5816                 });
5817
5818                 self.context.update_time_counter = cmp::max(self.context.update_time_counter, highest_header_time);
5819
5820                 if let Some(channel_ready) = self.check_get_channel_ready(height) {
5821                         let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
5822                                 self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger)
5823                         } else { None };
5824                         log_info!(logger, "Sending a channel_ready to our peer for channel {}", &self.context.channel_id);
5825                         return Ok((Some(channel_ready), timed_out_htlcs, announcement_sigs));
5826                 }
5827
5828                 if matches!(self.context.channel_state, ChannelState::ChannelReady(_)) ||
5829                         self.context.channel_state.is_our_channel_ready() {
5830                         let mut funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
5831                         if self.context.funding_tx_confirmation_height == 0 {
5832                                 // Note that check_get_channel_ready may reset funding_tx_confirmation_height to
5833                                 // zero if it has been reorged out, however in either case, our state flags
5834                                 // indicate we've already sent a channel_ready
5835                                 funding_tx_confirmations = 0;
5836                         }
5837
5838                         // If we've sent channel_ready (or have both sent and received channel_ready), and
5839                         // the funding transaction has become unconfirmed,
5840                         // close the channel and hope we can get the latest state on chain (because presumably
5841                         // the funding transaction is at least still in the mempool of most nodes).
5842                         //
5843                         // Note that ideally we wouldn't force-close if we see *any* reorg on a 1-conf or
5844                         // 0-conf channel, but not doing so may lead to the
5845                         // `ChannelManager::short_to_chan_info` map  being inconsistent, so we currently have
5846                         // to.
5847                         if funding_tx_confirmations == 0 && self.context.funding_tx_confirmed_in.is_some() {
5848                                 let err_reason = format!("Funding transaction was un-confirmed. Locked at {} confs, now have {} confs.",
5849                                         self.context.minimum_depth.unwrap(), funding_tx_confirmations);
5850                                 return Err(ClosureReason::ProcessingError { err: err_reason });
5851                         }
5852                 } else if !self.context.is_outbound() && self.context.funding_tx_confirmed_in.is_none() &&
5853                                 height >= self.context.channel_creation_height + FUNDING_CONF_DEADLINE_BLOCKS {
5854                         log_info!(logger, "Closing channel {} due to funding timeout", &self.context.channel_id);
5855                         // If funding_tx_confirmed_in is unset, the channel must not be active
5856                         assert!(self.context.channel_state <= ChannelState::ChannelReady(ChannelReadyFlags::new()));
5857                         assert!(!self.context.channel_state.is_our_channel_ready());
5858                         return Err(ClosureReason::FundingTimedOut);
5859                 }
5860
5861                 let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
5862                         self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger)
5863                 } else { None };
5864                 Ok((None, timed_out_htlcs, announcement_sigs))
5865         }
5866
5867         /// Indicates the funding transaction is no longer confirmed in the main chain. This may
5868         /// force-close the channel, but may also indicate a harmless reorganization of a block or two
5869         /// before the channel has reached channel_ready and we can just wait for more blocks.
5870         pub fn funding_transaction_unconfirmed<L: Deref>(&mut self, logger: &L) -> Result<(), ClosureReason> where L::Target: Logger {
5871                 if self.context.funding_tx_confirmation_height != 0 {
5872                         // We handle the funding disconnection by calling best_block_updated with a height one
5873                         // below where our funding was connected, implying a reorg back to conf_height - 1.
5874                         let reorg_height = self.context.funding_tx_confirmation_height - 1;
5875                         // We use the time field to bump the current time we set on channel updates if its
5876                         // larger. If we don't know that time has moved forward, we can just set it to the last
5877                         // time we saw and it will be ignored.
5878                         let best_time = self.context.update_time_counter;
5879                         match self.do_best_block_updated(reorg_height, best_time, None::<(ChainHash, &&dyn NodeSigner, &UserConfig)>, logger) {
5880                                 Ok((channel_ready, timed_out_htlcs, announcement_sigs)) => {
5881                                         assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
5882                                         assert!(timed_out_htlcs.is_empty(), "We can't have accepted HTLCs with a timeout before our funding confirmation?");
5883                                         assert!(announcement_sigs.is_none(), "We can't generate an announcement_sigs with 0 confirmations?");
5884                                         Ok(())
5885                                 },
5886                                 Err(e) => Err(e)
5887                         }
5888                 } else {
5889                         // We never learned about the funding confirmation anyway, just ignore
5890                         Ok(())
5891                 }
5892         }
5893
5894         // Methods to get unprompted messages to send to the remote end (or where we already returned
5895         // something in the handler for the message that prompted this message):
5896
5897         /// Gets an UnsignedChannelAnnouncement for this channel. The channel must be publicly
5898         /// announceable and available for use (have exchanged [`ChannelReady`] messages in both
5899         /// directions). Should be used for both broadcasted announcements and in response to an
5900         /// AnnouncementSignatures message from the remote peer.
5901         ///
5902         /// Will only fail if we're not in a state where channel_announcement may be sent (including
5903         /// closing).
5904         ///
5905         /// This will only return ChannelError::Ignore upon failure.
5906         ///
5907         /// [`ChannelReady`]: crate::ln::msgs::ChannelReady
5908         fn get_channel_announcement<NS: Deref>(
5909                 &self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
5910         ) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
5911                 if !self.context.config.announced_channel {
5912                         return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
5913                 }
5914                 if !self.context.is_usable() {
5915                         return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
5916                 }
5917
5918                 let short_channel_id = self.context.get_short_channel_id()
5919                         .ok_or(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel has not been confirmed yet".to_owned()))?;
5920                 let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
5921                         .map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
5922                 let counterparty_node_id = NodeId::from_pubkey(&self.context.get_counterparty_node_id());
5923                 let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();
5924
5925                 let msg = msgs::UnsignedChannelAnnouncement {
5926                         features: channelmanager::provided_channel_features(&user_config),
5927                         chain_hash,
5928                         short_channel_id,
5929                         node_id_1: if were_node_one { node_id } else { counterparty_node_id },
5930                         node_id_2: if were_node_one { counterparty_node_id } else { node_id },
5931                         bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &self.context.get_holder_pubkeys().funding_pubkey } else { self.context.counterparty_funding_pubkey() }),
5932                         bitcoin_key_2: NodeId::from_pubkey(if were_node_one { self.context.counterparty_funding_pubkey() } else { &self.context.get_holder_pubkeys().funding_pubkey }),
5933                         excess_data: Vec::new(),
5934                 };
5935
5936                 Ok(msg)
5937         }
5938
5939         fn get_announcement_sigs<NS: Deref, L: Deref>(
5940                 &mut self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
5941                 best_block_height: u32, logger: &L
5942         ) -> Option<msgs::AnnouncementSignatures>
5943         where
5944                 NS::Target: NodeSigner,
5945                 L::Target: Logger
5946         {
5947                 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
5948                         return None;
5949                 }
5950
5951                 if !self.context.is_usable() {
5952                         return None;
5953                 }
5954
5955                 if self.context.channel_state.is_peer_disconnected() {
5956                         log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
5957                         return None;
5958                 }
5959
5960                 if self.context.announcement_sigs_state != AnnouncementSigsState::NotSent {
5961                         return None;
5962                 }
5963
5964                 log_trace!(logger, "Creating an announcement_signatures message for channel {}", &self.context.channel_id());
5965                 let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
5966                         Ok(a) => a,
5967                         Err(e) => {
5968                                 log_trace!(logger, "{:?}", e);
5969                                 return None;
5970                         }
5971                 };
5972                 let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
5973                         Err(_) => {
5974                                 log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
5975                                 return None;
5976                         },
5977                         Ok(v) => v
5978                 };
5979                 match &self.context.holder_signer {
5980                         ChannelSignerType::Ecdsa(ecdsa) => {
5981                                 let our_bitcoin_sig = match ecdsa.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx) {
5982                                         Err(_) => {
5983                                                 log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
5984                                                 return None;
5985                                         },
5986                                         Ok(v) => v
5987                                 };
5988                                 let short_channel_id = match self.context.get_short_channel_id() {
5989                                         Some(scid) => scid,
5990                                         None => return None,
5991                                 };
5992
5993                                 self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
5994
5995                                 Some(msgs::AnnouncementSignatures {
5996                                         channel_id: self.context.channel_id(),
5997                                         short_channel_id,
5998                                         node_signature: our_node_sig,
5999                                         bitcoin_signature: our_bitcoin_sig,
6000                                 })
6001                         },
6002                         // TODO (taproot|arik)
6003                         #[cfg(taproot)]
6004                         _ => todo!()
6005                 }
6006         }
6007
6008         /// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are
6009         /// available.
6010         fn sign_channel_announcement<NS: Deref>(
6011                 &self, node_signer: &NS, announcement: msgs::UnsignedChannelAnnouncement
6012         ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
6013                 if let Some((their_node_sig, their_bitcoin_sig)) = self.context.announcement_sigs {
6014                         let our_node_key = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
6015                                 .map_err(|_| ChannelError::Ignore("Signer failed to retrieve own public key".to_owned()))?);
6016                         let were_node_one = announcement.node_id_1 == our_node_key;
6017
6018                         let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
6019                                 .map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
6020                         match &self.context.holder_signer {
6021                                 ChannelSignerType::Ecdsa(ecdsa) => {
6022                                         let our_bitcoin_sig = ecdsa.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx)
6023                                                 .map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
6024                                         Ok(msgs::ChannelAnnouncement {
6025                                                 node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
6026                                                 node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
6027                                                 bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
6028                                                 bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
6029                                                 contents: announcement,
6030                                         })
6031                                 },
6032                                 // TODO (taproot|arik)
6033                                 #[cfg(taproot)]
6034                                 _ => todo!()
6035                         }
6036                 } else {
6037                         Err(ChannelError::Ignore("Attempted to sign channel announcement before we'd received announcement_signatures".to_string()))
6038                 }
6039         }
6040
6041         /// Processes an incoming announcement_signatures message, providing a fully-signed
6042         /// channel_announcement message which we can broadcast and storing our counterparty's
6043         /// signatures for later reconstruction/rebroadcast of the channel_announcement.
6044         pub fn announcement_signatures<NS: Deref>(
6045                 &mut self, node_signer: &NS, chain_hash: ChainHash, best_block_height: u32,
6046                 msg: &msgs::AnnouncementSignatures, user_config: &UserConfig
6047         ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
6048                 let announcement = self.get_channel_announcement(node_signer, chain_hash, user_config)?;
6049
6050                 let msghash = hash_to_message!(&Sha256d::hash(&announcement.encode()[..])[..]);
6051
6052                 if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.context.get_counterparty_node_id()).is_err() {
6053                         return Err(ChannelError::Close(format!(
6054                                 "Bad announcement_signatures. Failed to verify node_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_node_key is {:?}",
6055                                  &announcement, self.context.get_counterparty_node_id())));
6056                 }
6057                 if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.context.counterparty_funding_pubkey()).is_err() {
6058                         return Err(ChannelError::Close(format!(
6059                                 "Bad announcement_signatures. Failed to verify bitcoin_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_bitcoin_key is ({:?})",
6060                                 &announcement, self.context.counterparty_funding_pubkey())));
6061                 }
6062
6063                 self.context.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
6064                 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
6065                         return Err(ChannelError::Ignore(
6066                                 "Got announcement_signatures prior to the required six confirmations - we may not have received a block yet that our peer has".to_owned()));
6067                 }
6068
6069                 self.sign_channel_announcement(node_signer, announcement)
6070         }
6071
6072         /// Gets a signed channel_announcement for this channel, if we previously received an
6073         /// announcement_signatures from our counterparty.
6074         pub fn get_signed_channel_announcement<NS: Deref>(
6075                 &self, node_signer: &NS, chain_hash: ChainHash, best_block_height: u32, user_config: &UserConfig
6076         ) -> Option<msgs::ChannelAnnouncement> where NS::Target: NodeSigner {
6077                 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
6078                         return None;
6079                 }
6080                 let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
6081                         Ok(res) => res,
6082                         Err(_) => return None,
6083                 };
6084                 match self.sign_channel_announcement(node_signer, announcement) {
6085                         Ok(res) => Some(res),
6086                         Err(_) => None,
6087                 }
6088         }
6089
6090         /// May panic if called on a channel that wasn't immediately-previously
6091         /// self.remove_uncommitted_htlcs_and_mark_paused()'d
6092         pub fn get_channel_reestablish<L: Deref>(&mut self, logger: &L) -> msgs::ChannelReestablish where L::Target: Logger {
6093                 assert!(self.context.channel_state.is_peer_disconnected());
6094                 assert_ne!(self.context.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
6095                 // Prior to static_remotekey, my_current_per_commitment_point was critical to claiming
6096                 // current to_remote balances. However, it no longer has any use, and thus is now simply
6097                 // set to a dummy (but valid, as required by the spec) public key.
6098                 // fuzzing mode marks a subset of pubkeys as invalid so that we can hit "invalid pubkey"
6099                 // branches, but we unwrap it below, so we arbitrarily select a dummy pubkey which is both
6100                 // valid, and valid in fuzzing mode's arbitrary validity criteria:
6101                 let mut pk = [2; 33]; pk[1] = 0xff;
6102                 let dummy_pubkey = PublicKey::from_slice(&pk).unwrap();
6103                 let remote_last_secret = if self.context.cur_counterparty_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
6104                         let remote_last_secret = self.context.commitment_secrets.get_secret(self.context.cur_counterparty_commitment_transaction_number + 2).unwrap();
6105                         log_trace!(logger, "Enough info to generate a Data Loss Protect with per_commitment_secret {} for channel {}", log_bytes!(remote_last_secret), &self.context.channel_id());
6106                         remote_last_secret
6107                 } else {
6108                         log_info!(logger, "Sending a data_loss_protect with no previous remote per_commitment_secret for channel {}", &self.context.channel_id());
6109                         [0;32]
6110                 };
6111                 self.mark_awaiting_response();
6112                 msgs::ChannelReestablish {
6113                         channel_id: self.context.channel_id(),
6114                         // The protocol has two different commitment number concepts - the "commitment
6115                         // transaction number", which starts from 0 and counts up, and the "revocation key
6116                         // index" which starts at INITIAL_COMMITMENT_NUMBER and counts down. We track
6117                         // commitment transaction numbers by the index which will be used to reveal the
6118                         // revocation key for that commitment transaction, which means we have to convert them
6119                         // to protocol-level commitment numbers here...
6120
6121                         // next_local_commitment_number is the next commitment_signed number we expect to
6122                         // receive (indicating if they need to resend one that we missed).
6123                         next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number,
6124                         // We have to set next_remote_commitment_number to the next revoke_and_ack we expect to
6125                         // receive, however we track it by the next commitment number for a remote transaction
6126                         // (which is one further, as they always revoke previous commitment transaction, not
6127                         // the one we send) so we have to decrement by 1. Note that if
6128                         // cur_counterparty_commitment_transaction_number is INITIAL_COMMITMENT_NUMBER we will have
6129                         // dropped this channel on disconnect as it hasn't yet reached AwaitingChannelReady so we can't
6130                         // overflow here.
6131                         next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number - 1,
6132                         your_last_per_commitment_secret: remote_last_secret,
6133                         my_current_per_commitment_point: dummy_pubkey,
6134                         // TODO(dual_funding): If we've sent `commtiment_signed` for an interactive transaction
6135                         // construction but have not received `tx_signatures` we MUST set `next_funding_txid` to the
6136                         // txid of that interactive transaction, else we MUST NOT set it.
6137                         next_funding_txid: None,
6138                 }
6139         }
6140
6141
6142         // Send stuff to our remote peers:
6143
6144         /// Queues up an outbound HTLC to send by placing it in the holding cell. You should call
6145         /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
6146         /// commitment update.
6147         ///
6148         /// `Err`s will only be [`ChannelError::Ignore`].
6149         pub fn queue_add_htlc<F: Deref, L: Deref>(
6150                 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
6151                 onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>,
6152                 blinding_point: Option<PublicKey>, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
6153         ) -> Result<(), ChannelError>
6154         where F::Target: FeeEstimator, L::Target: Logger
6155         {
6156                 self
6157                         .send_htlc(amount_msat, payment_hash, cltv_expiry, source, onion_routing_packet, true,
6158                                 skimmed_fee_msat, blinding_point, fee_estimator, logger)
6159                         .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
6160                         .map_err(|err| {
6161                                 if let ChannelError::Ignore(_) = err { /* fine */ }
6162                                 else { debug_assert!(false, "Queueing cannot trigger channel failure"); }
6163                                 err
6164                         })
6165         }
6166
6167         /// Adds a pending outbound HTLC to this channel, note that you probably want
6168         /// [`Self::send_htlc_and_commit`] instead cause you'll want both messages at once.
6169         ///
6170         /// This returns an optional UpdateAddHTLC as we may be in a state where we cannot add HTLCs on
6171         /// the wire:
6172         /// * In cases where we're waiting on the remote peer to send us a revoke_and_ack, we
6173         ///   wouldn't be able to determine what they actually ACK'ed if we have two sets of updates
6174         ///   awaiting ACK.
6175         /// * In cases where we're marked MonitorUpdateInProgress, we cannot commit to a new state as
6176         ///   we may not yet have sent the previous commitment update messages and will need to
6177         ///   regenerate them.
6178         ///
6179         /// You MUST call [`Self::send_commitment_no_state_update`] prior to calling any other methods
6180         /// on this [`Channel`] if `force_holding_cell` is false.
6181         ///
6182         /// `Err`s will only be [`ChannelError::Ignore`].
6183         fn send_htlc<F: Deref, L: Deref>(
6184                 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
6185                 onion_routing_packet: msgs::OnionPacket, mut force_holding_cell: bool,
6186                 skimmed_fee_msat: Option<u64>, blinding_point: Option<PublicKey>,
6187                 fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
6188         ) -> Result<Option<msgs::UpdateAddHTLC>, ChannelError>
6189         where F::Target: FeeEstimator, L::Target: Logger
6190         {
6191                 if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) ||
6192                         self.context.channel_state.is_local_shutdown_sent() ||
6193                         self.context.channel_state.is_remote_shutdown_sent()
6194                 {
6195                         return Err(ChannelError::Ignore("Cannot send HTLC until channel is fully established and we haven't started shutting down".to_owned()));
6196                 }
6197                 let channel_total_msat = self.context.channel_value_satoshis * 1000;
6198                 if amount_msat > channel_total_msat {
6199                         return Err(ChannelError::Ignore(format!("Cannot send amount {}, because it is more than the total value of the channel {}", amount_msat, channel_total_msat)));
6200                 }
6201
6202                 if amount_msat == 0 {
6203                         return Err(ChannelError::Ignore("Cannot send 0-msat HTLC".to_owned()));
6204                 }
6205
6206                 let available_balances = self.context.get_available_balances(fee_estimator);
6207                 if amount_msat < available_balances.next_outbound_htlc_minimum_msat {
6208                         return Err(ChannelError::Ignore(format!("Cannot send less than our next-HTLC minimum - {} msat",
6209                                 available_balances.next_outbound_htlc_minimum_msat)));
6210                 }
6211
6212                 if amount_msat > available_balances.next_outbound_htlc_limit_msat {
6213                         return Err(ChannelError::Ignore(format!("Cannot send more than our next-HTLC maximum - {} msat",
6214                                 available_balances.next_outbound_htlc_limit_msat)));
6215                 }
6216
6217                 if self.context.channel_state.is_peer_disconnected() {
6218                         // Note that this should never really happen, if we're !is_live() on receipt of an
6219                         // incoming HTLC for relay will result in us rejecting the HTLC and we won't allow
6220                         // the user to send directly into a !is_live() channel. However, if we
6221                         // disconnected during the time the previous hop was doing the commitment dance we may
6222                         // end up getting here after the forwarding delay. In any case, returning an
6223                         // IgnoreError will get ChannelManager to do the right thing and fail backwards now.
6224                         return Err(ChannelError::Ignore("Cannot send an HTLC while disconnected from channel counterparty".to_owned()));
6225                 }
6226
6227                 let need_holding_cell = !self.context.channel_state.can_generate_new_commitment();
6228                 log_debug!(logger, "Pushing new outbound HTLC with hash {} for {} msat {}",
6229                         payment_hash, amount_msat,
6230                         if force_holding_cell { "into holding cell" }
6231                         else if need_holding_cell { "into holding cell as we're awaiting an RAA or monitor" }
6232                         else { "to peer" });
6233
6234                 if need_holding_cell {
6235                         force_holding_cell = true;
6236                 }
6237
6238                 // Now update local state:
6239                 if force_holding_cell {
6240                         self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
6241                                 amount_msat,
6242                                 payment_hash,
6243                                 cltv_expiry,
6244                                 source,
6245                                 onion_routing_packet,
6246                                 skimmed_fee_msat,
6247                                 blinding_point,
6248                         });
6249                         return Ok(None);
6250                 }
6251
6252                 self.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
6253                         htlc_id: self.context.next_holder_htlc_id,
6254                         amount_msat,
6255                         payment_hash: payment_hash.clone(),
6256                         cltv_expiry,
6257                         state: OutboundHTLCState::LocalAnnounced(Box::new(onion_routing_packet.clone())),
6258                         source,
6259                         blinding_point,
6260                         skimmed_fee_msat,
6261                 });
6262
6263                 let res = msgs::UpdateAddHTLC {
6264                         channel_id: self.context.channel_id,
6265                         htlc_id: self.context.next_holder_htlc_id,
6266                         amount_msat,
6267                         payment_hash,
6268                         cltv_expiry,
6269                         onion_routing_packet,
6270                         skimmed_fee_msat,
6271                         blinding_point,
6272                 };
6273                 self.context.next_holder_htlc_id += 1;
6274
6275                 Ok(Some(res))
6276         }
6277
6278         fn build_commitment_no_status_check<L: Deref>(&mut self, logger: &L) -> ChannelMonitorUpdate where L::Target: Logger {
6279                 log_trace!(logger, "Updating HTLC state for a newly-sent commitment_signed...");
6280                 // We can upgrade the status of some HTLCs that are waiting on a commitment, even if we
6281                 // fail to generate this, we still are at least at a position where upgrading their status
6282                 // is acceptable.
6283                 for htlc in self.context.pending_inbound_htlcs.iter_mut() {
6284                         let new_state = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref forward_info) = &htlc.state {
6285                                 Some(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info.clone()))
6286                         } else { None };
6287                         if let Some(state) = new_state {
6288                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", &htlc.payment_hash);
6289                                 htlc.state = state;
6290                         }
6291                 }
6292                 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
6293                         if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
6294                                 log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", &htlc.payment_hash);
6295                                 // Grab the preimage, if it exists, instead of cloning
6296                                 let mut reason = OutboundHTLCOutcome::Success(None);
6297                                 mem::swap(outcome, &mut reason);
6298                                 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
6299                         }
6300                 }
6301                 if let Some((feerate, update_state)) = self.context.pending_update_fee {
6302                         if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {
6303                                 debug_assert!(!self.context.is_outbound());
6304                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
6305                                 self.context.feerate_per_kw = feerate;
6306                                 self.context.pending_update_fee = None;
6307                         }
6308                 }
6309                 self.context.resend_order = RAACommitmentOrder::RevokeAndACKFirst;
6310
6311                 let (mut htlcs_ref, counterparty_commitment_tx) =
6312                         self.build_commitment_no_state_update(logger);
6313                 let counterparty_commitment_txid = counterparty_commitment_tx.trust().txid();
6314                 let htlcs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)> =
6315                         htlcs_ref.drain(..).map(|(htlc, htlc_source)| (htlc, htlc_source.map(|source_ref| Box::new(source_ref.clone())))).collect();
6316
6317                 if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent {
6318                         self.context.announcement_sigs_state = AnnouncementSigsState::Committed;
6319                 }
6320
6321                 self.context.latest_monitor_update_id += 1;
6322                 let monitor_update = ChannelMonitorUpdate {
6323                         update_id: self.context.latest_monitor_update_id,
6324                         counterparty_node_id: Some(self.context.counterparty_node_id),
6325                         updates: vec![ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
6326                                 commitment_txid: counterparty_commitment_txid,
6327                                 htlc_outputs: htlcs.clone(),
6328                                 commitment_number: self.context.cur_counterparty_commitment_transaction_number,
6329                                 their_per_commitment_point: self.context.counterparty_cur_commitment_point.unwrap(),
6330                                 feerate_per_kw: Some(counterparty_commitment_tx.feerate_per_kw()),
6331                                 to_broadcaster_value_sat: Some(counterparty_commitment_tx.to_broadcaster_value_sat()),
6332                                 to_countersignatory_value_sat: Some(counterparty_commitment_tx.to_countersignatory_value_sat()),
6333                         }],
6334                         channel_id: Some(self.context.channel_id()),
6335                 };
6336                 self.context.channel_state.set_awaiting_remote_revoke();
6337                 monitor_update
6338         }
6339
6340         fn build_commitment_no_state_update<L: Deref>(&self, logger: &L)
6341         -> (Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>, CommitmentTransaction)
6342         where L::Target: Logger
6343         {
6344                 let counterparty_keys = self.context.build_remote_transaction_keys();
6345                 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
6346                 let counterparty_commitment_tx = commitment_stats.tx;
6347
6348                 #[cfg(any(test, fuzzing))]
6349                 {
6350                         if !self.context.is_outbound() {
6351                                 let projected_commit_tx_info = self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap().take();
6352                                 *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
6353                                 if let Some(info) = projected_commit_tx_info {
6354                                         let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
6355                                         if info.total_pending_htlcs == total_pending_htlcs
6356                                                 && info.next_holder_htlc_id == self.context.next_holder_htlc_id
6357                                                 && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
6358                                                 && info.feerate == self.context.feerate_per_kw {
6359                                                         let actual_fee = commit_tx_fee_msat(self.context.feerate_per_kw, commitment_stats.num_nondust_htlcs, self.context.get_channel_type());
6360                                                         assert_eq!(actual_fee, info.fee);
6361                                                 }
6362                                 }
6363                         }
6364                 }
6365
6366                 (commitment_stats.htlcs_included, counterparty_commitment_tx)
6367         }
6368
6369         /// Only fails in case of signer rejection. Used for channel_reestablish commitment_signed
6370         /// generation when we shouldn't change HTLC/channel state.
6371         fn send_commitment_no_state_update<L: Deref>(&self, logger: &L) -> Result<(msgs::CommitmentSigned, (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>)), ChannelError> where L::Target: Logger {
6372                 // Get the fee tests from `build_commitment_no_state_update`
6373                 #[cfg(any(test, fuzzing))]
6374                 self.build_commitment_no_state_update(logger);
6375
6376                 let counterparty_keys = self.context.build_remote_transaction_keys();
6377                 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
6378                 let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
6379
6380                 match &self.context.holder_signer {
6381                         ChannelSignerType::Ecdsa(ecdsa) => {
6382                                 let (signature, htlc_signatures);
6383
6384                                 {
6385                                         let mut htlcs = Vec::with_capacity(commitment_stats.htlcs_included.len());
6386                                         for &(ref htlc, _) in commitment_stats.htlcs_included.iter() {
6387                                                 htlcs.push(htlc);
6388                                         }
6389
6390                                         let res = ecdsa.sign_counterparty_commitment(
6391                                                         &commitment_stats.tx,
6392                                                         commitment_stats.inbound_htlc_preimages,
6393                                                         commitment_stats.outbound_htlc_preimages,
6394                                                         &self.context.secp_ctx,
6395                                                 ).map_err(|_| ChannelError::Ignore("Failed to get signatures for new commitment_signed".to_owned()))?;
6396                                         signature = res.0;
6397                                         htlc_signatures = res.1;
6398
6399                                         log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {} in channel {}",
6400                                                 encode::serialize_hex(&commitment_stats.tx.trust().built_transaction().transaction),
6401                                                 &counterparty_commitment_txid, encode::serialize_hex(&self.context.get_funding_redeemscript()),
6402                                                 log_bytes!(signature.serialize_compact()[..]), &self.context.channel_id());
6403
6404                                         for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(htlcs) {
6405                                                 log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {} in channel {}",
6406                                                         encode::serialize_hex(&chan_utils::build_htlc_transaction(&counterparty_commitment_txid, commitment_stats.feerate_per_kw, self.context.get_holder_selected_contest_delay(), htlc, &self.context.channel_type, &counterparty_keys.broadcaster_delayed_payment_key, &counterparty_keys.revocation_key)),
6407                                                         encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &counterparty_keys)),
6408                                                         log_bytes!(counterparty_keys.broadcaster_htlc_key.to_public_key().serialize()),
6409                                                         log_bytes!(htlc_sig.serialize_compact()[..]), &self.context.channel_id());
6410                                         }
6411                                 }
6412
6413                                 Ok((msgs::CommitmentSigned {
6414                                         channel_id: self.context.channel_id,
6415                                         signature,
6416                                         htlc_signatures,
6417                                         #[cfg(taproot)]
6418                                         partial_signature_with_nonce: None,
6419                                 }, (counterparty_commitment_txid, commitment_stats.htlcs_included)))
6420                         },
6421                         // TODO (taproot|arik)
6422                         #[cfg(taproot)]
6423                         _ => todo!()
6424                 }
6425         }
6426
6427         /// Adds a pending outbound HTLC to this channel, and builds a new remote commitment
6428         /// transaction and generates the corresponding [`ChannelMonitorUpdate`] in one go.
6429         ///
6430         /// Shorthand for calling [`Self::send_htlc`] followed by a commitment update, see docs on
6431         /// [`Self::send_htlc`] and [`Self::build_commitment_no_state_update`] for more info.
6432         pub fn send_htlc_and_commit<F: Deref, L: Deref>(
6433                 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32,
6434                 source: HTLCSource, onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>,
6435                 fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
6436         ) -> Result<Option<ChannelMonitorUpdate>, ChannelError>
6437         where F::Target: FeeEstimator, L::Target: Logger
6438         {
6439                 let send_res = self.send_htlc(amount_msat, payment_hash, cltv_expiry, source,
6440                         onion_routing_packet, false, skimmed_fee_msat, None, fee_estimator, logger);
6441                 if let Err(e) = &send_res { if let ChannelError::Ignore(_) = e {} else { debug_assert!(false, "Sending cannot trigger channel failure"); } }
6442                 match send_res? {
6443                         Some(_) => {
6444                                 let monitor_update = self.build_commitment_no_status_check(logger);
6445                                 self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
6446                                 Ok(self.push_ret_blockable_mon_update(monitor_update))
6447                         },
6448                         None => Ok(None)
6449                 }
6450         }
6451
6452         /// Applies the `ChannelUpdate` and returns a boolean indicating whether a change actually
6453         /// happened.
6454         pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<bool, ChannelError> {
6455                 let new_forwarding_info = Some(CounterpartyForwardingInfo {
6456                         fee_base_msat: msg.contents.fee_base_msat,
6457                         fee_proportional_millionths: msg.contents.fee_proportional_millionths,
6458                         cltv_expiry_delta: msg.contents.cltv_expiry_delta
6459                 });
6460                 let did_change = self.context.counterparty_forwarding_info != new_forwarding_info;
6461                 if did_change {
6462                         self.context.counterparty_forwarding_info = new_forwarding_info;
6463                 }
6464
6465                 Ok(did_change)
6466         }
6467
6468         /// Begins the shutdown process, getting a message for the remote peer and returning all
6469         /// holding cell HTLCs for payment failure.
6470         pub fn get_shutdown(&mut self, signer_provider: &SP, their_features: &InitFeatures,
6471                 target_feerate_sats_per_kw: Option<u32>, override_shutdown_script: Option<ShutdownScript>)
6472         -> Result<(msgs::Shutdown, Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), APIError>
6473         {
6474                 for htlc in self.context.pending_outbound_htlcs.iter() {
6475                         if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
6476                                 return Err(APIError::APIMisuseError{err: "Cannot begin shutdown with pending HTLCs. Process pending events first".to_owned()});
6477                         }
6478                 }
6479                 if self.context.channel_state.is_local_shutdown_sent() {
6480                         return Err(APIError::APIMisuseError{err: "Shutdown already in progress".to_owned()});
6481                 }
6482                 else if self.context.channel_state.is_remote_shutdown_sent() {
6483                         return Err(APIError::ChannelUnavailable{err: "Shutdown already in progress by remote".to_owned()});
6484                 }
6485                 if self.context.shutdown_scriptpubkey.is_some() && override_shutdown_script.is_some() {
6486                         return Err(APIError::APIMisuseError{err: "Cannot override shutdown script for a channel with one already set".to_owned()});
6487                 }
6488                 assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
6489                 if self.context.channel_state.is_peer_disconnected() || self.context.channel_state.is_monitor_update_in_progress() {
6490                         return Err(APIError::ChannelUnavailable{err: "Cannot begin shutdown while peer is disconnected or we're waiting on a monitor update, maybe force-close instead?".to_owned()});
6491                 }
6492
6493                 let update_shutdown_script = match self.context.shutdown_scriptpubkey {
6494                         Some(_) => false,
6495                         None => {
6496                                 // use override shutdown script if provided
6497                                 let shutdown_scriptpubkey = match override_shutdown_script {
6498                                         Some(script) => script,
6499                                         None => {
6500                                                 // otherwise, use the shutdown scriptpubkey provided by the signer
6501                                                 match signer_provider.get_shutdown_scriptpubkey() {
6502                                                         Ok(scriptpubkey) => scriptpubkey,
6503                                                         Err(_) => return Err(APIError::ChannelUnavailable{err: "Failed to get shutdown scriptpubkey".to_owned()}),
6504                                                 }
6505                                         },
6506                                 };
6507                                 if !shutdown_scriptpubkey.is_compatible(their_features) {
6508                                         return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
6509                                 }
6510                                 self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
6511                                 true
6512                         },
6513                 };
6514
6515                 // From here on out, we may not fail!
6516                 self.context.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
6517                 self.context.channel_state.set_local_shutdown_sent();
6518                 self.context.local_initiated_shutdown = Some(());
6519                 self.context.update_time_counter += 1;
6520
6521                 let monitor_update = if update_shutdown_script {
6522                         self.context.latest_monitor_update_id += 1;
6523                         let monitor_update = ChannelMonitorUpdate {
6524                                 update_id: self.context.latest_monitor_update_id,
6525                                 counterparty_node_id: Some(self.context.counterparty_node_id),
6526                                 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
6527                                         scriptpubkey: self.get_closing_scriptpubkey(),
6528                                 }],
6529                                 channel_id: Some(self.context.channel_id()),
6530                         };
6531                         self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
6532                         self.push_ret_blockable_mon_update(monitor_update)
6533                 } else { None };
6534                 let shutdown = msgs::Shutdown {
6535                         channel_id: self.context.channel_id,
6536                         scriptpubkey: self.get_closing_scriptpubkey(),
6537                 };
6538
6539                 // Go ahead and drop holding cell updates as we'd rather fail payments than wait to send
6540                 // our shutdown until we've committed all of the pending changes.
6541                 self.context.holding_cell_update_fee = None;
6542                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
6543                 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
6544                         match htlc_update {
6545                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
6546                                         dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
6547                                         false
6548                                 },
6549                                 _ => true
6550                         }
6551                 });
6552
6553                 debug_assert!(!self.is_shutdown() || monitor_update.is_none(),
6554                         "we can't both complete shutdown and return a monitor update");
6555
6556                 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
6557         }
6558
6559         pub fn inflight_htlc_sources(&self) -> impl Iterator<Item=(&HTLCSource, &PaymentHash)> {
6560                 self.context.holding_cell_htlc_updates.iter()
6561                         .flat_map(|htlc_update| {
6562                                 match htlc_update {
6563                                         HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. }
6564                                                 => Some((source, payment_hash)),
6565                                         _ => None,
6566                                 }
6567                         })
6568                         .chain(self.context.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
6569         }
6570 }
6571
6572 /// A not-yet-funded outbound (from holder) channel using V1 channel establishment.
6573 pub(super) struct OutboundV1Channel<SP: Deref> where SP::Target: SignerProvider {
6574         pub context: ChannelContext<SP>,
6575         pub unfunded_context: UnfundedChannelContext,
6576 }
6577
6578 impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
6579         pub fn new<ES: Deref, F: Deref>(
6580                 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, counterparty_node_id: PublicKey, their_features: &InitFeatures,
6581                 channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig, current_chain_height: u32,
6582                 outbound_scid_alias: u64, temporary_channel_id: Option<ChannelId>
6583         ) -> Result<OutboundV1Channel<SP>, APIError>
6584         where ES::Target: EntropySource,
6585               F::Target: FeeEstimator
6586         {
6587                 let holder_selected_contest_delay = config.channel_handshake_config.our_to_self_delay;
6588                 let channel_keys_id = signer_provider.generate_channel_keys_id(false, channel_value_satoshis, user_id);
6589                 let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
6590                 let pubkeys = holder_signer.pubkeys().clone();
6591
6592                 if !their_features.supports_wumbo() && channel_value_satoshis > MAX_FUNDING_SATOSHIS_NO_WUMBO {
6593                         return Err(APIError::APIMisuseError{err: format!("funding_value must not exceed {}, it was {}", MAX_FUNDING_SATOSHIS_NO_WUMBO, channel_value_satoshis)});
6594                 }
6595                 if channel_value_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
6596                         return Err(APIError::APIMisuseError{err: format!("funding_value must be smaller than the total bitcoin supply, it was {}", channel_value_satoshis)});
6597                 }
6598                 let channel_value_msat = channel_value_satoshis * 1000;
6599                 if push_msat > channel_value_msat {
6600                         return Err(APIError::APIMisuseError { err: format!("Push value ({}) was larger than channel_value ({})", push_msat, channel_value_msat) });
6601                 }
6602                 if holder_selected_contest_delay < BREAKDOWN_TIMEOUT {
6603                         return Err(APIError::APIMisuseError {err: format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks", holder_selected_contest_delay)});
6604                 }
6605                 let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(channel_value_satoshis, config);
6606                 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
6607                         // Protocol level safety check in place, although it should never happen because
6608                         // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
6609                         return Err(APIError::APIMisuseError { err: format!("Holder selected channel  reserve below implemention limit dust_limit_satoshis {}", holder_selected_channel_reserve_satoshis) });
6610                 }
6611
6612                 let channel_type = Self::get_initial_channel_type(&config, their_features);
6613                 debug_assert!(channel_type.is_subset(&channelmanager::provided_channel_type_features(&config)));
6614
6615                 let (commitment_conf_target, anchor_outputs_value_msat)  = if channel_type.supports_anchors_zero_fee_htlc_tx() {
6616                         (ConfirmationTarget::AnchorChannelFee, ANCHOR_OUTPUT_VALUE_SATOSHI * 2 * 1000)
6617                 } else {
6618                         (ConfirmationTarget::NonAnchorChannelFee, 0)
6619                 };
6620                 let commitment_feerate = fee_estimator.bounded_sat_per_1000_weight(commitment_conf_target);
6621
6622                 let value_to_self_msat = channel_value_satoshis * 1000 - push_msat;
6623                 let commitment_tx_fee = commit_tx_fee_msat(commitment_feerate, MIN_AFFORDABLE_HTLC_COUNT, &channel_type);
6624                 if value_to_self_msat.saturating_sub(anchor_outputs_value_msat) < commitment_tx_fee {
6625                         return Err(APIError::APIMisuseError{ err: format!("Funding amount ({}) can't even pay fee for initial commitment transaction fee of {}.", value_to_self_msat / 1000, commitment_tx_fee / 1000) });
6626                 }
6627
6628                 let mut secp_ctx = Secp256k1::new();
6629                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
6630
6631                 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
6632                         match signer_provider.get_shutdown_scriptpubkey() {
6633                                 Ok(scriptpubkey) => Some(scriptpubkey),
6634                                 Err(_) => return Err(APIError::ChannelUnavailable { err: "Failed to get shutdown scriptpubkey".to_owned()}),
6635                         }
6636                 } else { None };
6637
6638                 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
6639                         if !shutdown_scriptpubkey.is_compatible(&their_features) {
6640                                 return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
6641                         }
6642                 }
6643
6644                 let destination_script = match signer_provider.get_destination_script(channel_keys_id) {
6645                         Ok(script) => script,
6646                         Err(_) => return Err(APIError::ChannelUnavailable { err: "Failed to get destination script".to_owned()}),
6647                 };
6648
6649                 let temporary_channel_id = temporary_channel_id.unwrap_or_else(|| ChannelId::temporary_from_entropy_source(entropy_source));
6650
6651                 Ok(Self {
6652                         context: ChannelContext {
6653                                 user_id,
6654
6655                                 config: LegacyChannelConfig {
6656                                         options: config.channel_config.clone(),
6657                                         announced_channel: config.channel_handshake_config.announced_channel,
6658                                         commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
6659                                 },
6660
6661                                 prev_config: None,
6662
6663                                 inbound_handshake_limits_override: Some(config.channel_handshake_limits.clone()),
6664
6665                                 channel_id: temporary_channel_id,
6666                                 temporary_channel_id: Some(temporary_channel_id),
6667                                 channel_state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::OUR_INIT_SENT),
6668                                 announcement_sigs_state: AnnouncementSigsState::NotSent,
6669                                 secp_ctx,
6670                                 channel_value_satoshis,
6671
6672                                 latest_monitor_update_id: 0,
6673
6674                                 holder_signer: ChannelSignerType::Ecdsa(holder_signer),
6675                                 shutdown_scriptpubkey,
6676                                 destination_script,
6677
6678                                 cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
6679                                 cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
6680                                 value_to_self_msat,
6681
6682                                 pending_inbound_htlcs: Vec::new(),
6683                                 pending_outbound_htlcs: Vec::new(),
6684                                 holding_cell_htlc_updates: Vec::new(),
6685                                 pending_update_fee: None,
6686                                 holding_cell_update_fee: None,
6687                                 next_holder_htlc_id: 0,
6688                                 next_counterparty_htlc_id: 0,
6689                                 update_time_counter: 1,
6690
6691                                 resend_order: RAACommitmentOrder::CommitmentFirst,
6692
6693                                 monitor_pending_channel_ready: false,
6694                                 monitor_pending_revoke_and_ack: false,
6695                                 monitor_pending_commitment_signed: false,
6696                                 monitor_pending_forwards: Vec::new(),
6697                                 monitor_pending_failures: Vec::new(),
6698                                 monitor_pending_finalized_fulfills: Vec::new(),
6699
6700                                 signer_pending_commitment_update: false,
6701                                 signer_pending_funding: false,
6702
6703                                 #[cfg(debug_assertions)]
6704                                 holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
6705                                 #[cfg(debug_assertions)]
6706                                 counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
6707
6708                                 last_sent_closing_fee: None,
6709                                 pending_counterparty_closing_signed: None,
6710                                 expecting_peer_commitment_signed: false,
6711                                 closing_fee_limits: None,
6712                                 target_closing_feerate_sats_per_kw: None,
6713
6714                                 funding_tx_confirmed_in: None,
6715                                 funding_tx_confirmation_height: 0,
6716                                 short_channel_id: None,
6717                                 channel_creation_height: current_chain_height,
6718
6719                                 feerate_per_kw: commitment_feerate,
6720                                 counterparty_dust_limit_satoshis: 0,
6721                                 holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
6722                                 counterparty_max_htlc_value_in_flight_msat: 0,
6723                                 holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &config.channel_handshake_config),
6724                                 counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
6725                                 holder_selected_channel_reserve_satoshis,
6726                                 counterparty_htlc_minimum_msat: 0,
6727                                 holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
6728                                 counterparty_max_accepted_htlcs: 0,
6729                                 holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
6730                                 minimum_depth: None, // Filled in in accept_channel
6731
6732                                 counterparty_forwarding_info: None,
6733
6734                                 channel_transaction_parameters: ChannelTransactionParameters {
6735                                         holder_pubkeys: pubkeys,
6736                                         holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
6737                                         is_outbound_from_holder: true,
6738                                         counterparty_parameters: None,
6739                                         funding_outpoint: None,
6740                                         channel_type_features: channel_type.clone()
6741                                 },
6742                                 funding_transaction: None,
6743                                 is_batch_funding: None,
6744
6745                                 counterparty_cur_commitment_point: None,
6746                                 counterparty_prev_commitment_point: None,
6747                                 counterparty_node_id,
6748
6749                                 counterparty_shutdown_scriptpubkey: None,
6750
6751                                 commitment_secrets: CounterpartyCommitmentSecrets::new(),
6752
6753                                 channel_update_status: ChannelUpdateStatus::Enabled,
6754                                 closing_signed_in_flight: false,
6755
6756                                 announcement_sigs: None,
6757
6758                                 #[cfg(any(test, fuzzing))]
6759                                 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
6760                                 #[cfg(any(test, fuzzing))]
6761                                 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
6762
6763                                 workaround_lnd_bug_4006: None,
6764                                 sent_message_awaiting_response: None,
6765
6766                                 latest_inbound_scid_alias: None,
6767                                 outbound_scid_alias,
6768
6769                                 channel_pending_event_emitted: false,
6770                                 channel_ready_event_emitted: false,
6771
6772                                 #[cfg(any(test, fuzzing))]
6773                                 historical_inbound_htlc_fulfills: new_hash_set(),
6774
6775                                 channel_type,
6776                                 channel_keys_id,
6777
6778                                 blocked_monitor_updates: Vec::new(),
6779                                 local_initiated_shutdown: None,
6780                         },
6781                         unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 }
6782                 })
6783         }
6784
6785         /// Only allowed after [`ChannelContext::channel_transaction_parameters`] is set.
6786         fn get_funding_created_msg<L: Deref>(&mut self, logger: &L) -> Option<msgs::FundingCreated> where L::Target: Logger {
6787                 let counterparty_keys = self.context.build_remote_transaction_keys();
6788                 let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
6789                 let signature = match &self.context.holder_signer {
6790                         // TODO (taproot|arik): move match into calling method for Taproot
6791                         ChannelSignerType::Ecdsa(ecdsa) => {
6792                                 ecdsa.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), Vec::new(), &self.context.secp_ctx)
6793                                         .map(|(sig, _)| sig).ok()?
6794                         },
6795                         // TODO (taproot|arik)
6796                         #[cfg(taproot)]
6797                         _ => todo!()
6798                 };
6799
6800                 if self.context.signer_pending_funding {
6801                         log_trace!(logger, "Counterparty commitment signature ready for funding_created message: clearing signer_pending_funding");
6802                         self.context.signer_pending_funding = false;
6803                 }
6804
6805                 Some(msgs::FundingCreated {
6806                         temporary_channel_id: self.context.temporary_channel_id.unwrap(),
6807                         funding_txid: self.context.channel_transaction_parameters.funding_outpoint.as_ref().unwrap().txid,
6808                         funding_output_index: self.context.channel_transaction_parameters.funding_outpoint.as_ref().unwrap().index,
6809                         signature,
6810                         #[cfg(taproot)]
6811                         partial_signature_with_nonce: None,
6812                         #[cfg(taproot)]
6813                         next_local_nonce: None,
6814                 })
6815         }
6816
6817         /// Updates channel state with knowledge of the funding transaction's txid/index, and generates
6818         /// a funding_created message for the remote peer.
6819         /// Panics if called at some time other than immediately after initial handshake, if called twice,
6820         /// or if called on an inbound channel.
6821         /// Note that channel_id changes during this call!
6822         /// Do NOT broadcast the funding transaction until after a successful funding_signed call!
6823         /// If an Err is returned, it is a ChannelError::Close.
6824         pub fn get_funding_created<L: Deref>(&mut self, funding_transaction: Transaction, funding_txo: OutPoint, is_batch_funding: bool, logger: &L)
6825         -> Result<Option<msgs::FundingCreated>, (Self, ChannelError)> where L::Target: Logger {
6826                 if !self.context.is_outbound() {
6827                         panic!("Tried to create outbound funding_created message on an inbound channel!");
6828                 }
6829                 if !matches!(
6830                         self.context.channel_state, ChannelState::NegotiatingFunding(flags)
6831                         if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
6832                 ) {
6833                         panic!("Tried to get a funding_created messsage at a time other than immediately after initial handshake completion (or tried to get funding_created twice)");
6834                 }
6835                 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
6836                                 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
6837                                 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
6838                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
6839                 }
6840
6841                 self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
6842                 self.context.holder_signer.as_mut().provide_channel_parameters(&self.context.channel_transaction_parameters);
6843
6844                 // Now that we're past error-generating stuff, update our local state:
6845
6846                 self.context.channel_state = ChannelState::FundingNegotiated;
6847                 self.context.channel_id = ChannelId::v1_from_funding_outpoint(funding_txo);
6848
6849                 // If the funding transaction is a coinbase transaction, we need to set the minimum depth to 100.
6850                 // We can skip this if it is a zero-conf channel.
6851                 if funding_transaction.is_coin_base() &&
6852                         self.context.minimum_depth.unwrap_or(0) > 0 &&
6853                         self.context.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
6854                         self.context.minimum_depth = Some(COINBASE_MATURITY);
6855                 }
6856
6857                 self.context.funding_transaction = Some(funding_transaction);
6858                 self.context.is_batch_funding = Some(()).filter(|_| is_batch_funding);
6859
6860                 let funding_created = self.get_funding_created_msg(logger);
6861                 if funding_created.is_none() {
6862                         #[cfg(not(async_signing))] {
6863                                 panic!("Failed to get signature for new funding creation");
6864                         }
6865                         #[cfg(async_signing)] {
6866                                 if !self.context.signer_pending_funding {
6867                                         log_trace!(logger, "funding_created awaiting signer; setting signer_pending_funding");
6868                                         self.context.signer_pending_funding = true;
6869                                 }
6870                         }
6871                 }
6872
6873                 Ok(funding_created)
6874         }
6875
6876         fn get_initial_channel_type(config: &UserConfig, their_features: &InitFeatures) -> ChannelTypeFeatures {
6877                 // The default channel type (ie the first one we try) depends on whether the channel is
6878                 // public - if it is, we just go with `only_static_remotekey` as it's the only option
6879                 // available. If it's private, we first try `scid_privacy` as it provides better privacy
6880                 // with no other changes, and fall back to `only_static_remotekey`.
6881                 let mut ret = ChannelTypeFeatures::only_static_remote_key();
6882                 if !config.channel_handshake_config.announced_channel &&
6883                         config.channel_handshake_config.negotiate_scid_privacy &&
6884                         their_features.supports_scid_privacy() {
6885                         ret.set_scid_privacy_required();
6886                 }
6887
6888                 // Optionally, if the user would like to negotiate the `anchors_zero_fee_htlc_tx` option, we
6889                 // set it now. If they don't understand it, we'll fall back to our default of
6890                 // `only_static_remotekey`.
6891                 if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
6892                         their_features.supports_anchors_zero_fee_htlc_tx() {
6893                         ret.set_anchors_zero_fee_htlc_tx_required();
6894                 }
6895
6896                 ret
6897         }
6898
6899         /// If we receive an error message, it may only be a rejection of the channel type we tried,
6900         /// not of our ability to open any channel at all. Thus, on error, we should first call this
6901         /// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
6902         pub(crate) fn maybe_handle_error_without_close<F: Deref>(
6903                 &mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>
6904         ) -> Result<msgs::OpenChannel, ()>
6905         where
6906                 F::Target: FeeEstimator
6907         {
6908                 if !self.context.is_outbound() ||
6909                         !matches!(
6910                                 self.context.channel_state, ChannelState::NegotiatingFunding(flags)
6911                                 if flags == NegotiatingFundingFlags::OUR_INIT_SENT
6912                         )
6913                 {
6914                         return Err(());
6915                 }
6916                 if self.context.channel_type == ChannelTypeFeatures::only_static_remote_key() {
6917                         // We've exhausted our options
6918                         return Err(());
6919                 }
6920                 // We support opening a few different types of channels. Try removing our additional
6921                 // features one by one until we've either arrived at our default or the counterparty has
6922                 // accepted one.
6923                 //
6924                 // Due to the order below, we may not negotiate `option_anchors_zero_fee_htlc_tx` if the
6925                 // counterparty doesn't support `option_scid_privacy`. Since `get_initial_channel_type`
6926                 // checks whether the counterparty supports every feature, this would only happen if the
6927                 // counterparty is advertising the feature, but rejecting channels proposing the feature for
6928                 // whatever reason.
6929                 if self.context.channel_type.supports_anchors_zero_fee_htlc_tx() {
6930                         self.context.channel_type.clear_anchors_zero_fee_htlc_tx();
6931                         self.context.feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
6932                         assert!(!self.context.channel_transaction_parameters.channel_type_features.supports_anchors_nonzero_fee_htlc_tx());
6933                 } else if self.context.channel_type.supports_scid_privacy() {
6934                         self.context.channel_type.clear_scid_privacy();
6935                 } else {
6936                         self.context.channel_type = ChannelTypeFeatures::only_static_remote_key();
6937                 }
6938                 self.context.channel_transaction_parameters.channel_type_features = self.context.channel_type.clone();
6939                 Ok(self.get_open_channel(chain_hash))
6940         }
6941
6942         pub fn get_open_channel(&self, chain_hash: ChainHash) -> msgs::OpenChannel {
6943                 if !self.context.is_outbound() {
6944                         panic!("Tried to open a channel for an inbound channel?");
6945                 }
6946                 if self.context.have_received_message() {
6947                         panic!("Cannot generate an open_channel after we've moved forward");
6948                 }
6949
6950                 if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
6951                         panic!("Tried to send an open_channel for a channel that has already advanced");
6952                 }
6953
6954                 let first_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
6955                 let keys = self.context.get_holder_pubkeys();
6956
6957                 msgs::OpenChannel {
6958                         chain_hash,
6959                         temporary_channel_id: self.context.channel_id,
6960                         funding_satoshis: self.context.channel_value_satoshis,
6961                         push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
6962                         dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
6963                         max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
6964                         channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
6965                         htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
6966                         feerate_per_kw: self.context.feerate_per_kw as u32,
6967                         to_self_delay: self.context.get_holder_selected_contest_delay(),
6968                         max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
6969                         funding_pubkey: keys.funding_pubkey,
6970                         revocation_basepoint: keys.revocation_basepoint.to_public_key(),
6971                         payment_point: keys.payment_point,
6972                         delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
6973                         htlc_basepoint: keys.htlc_basepoint.to_public_key(),
6974                         first_per_commitment_point,
6975                         channel_flags: if self.context.config.announced_channel {1} else {0},
6976                         shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
6977                                 Some(script) => script.clone().into_inner(),
6978                                 None => Builder::new().into_script(),
6979                         }),
6980                         channel_type: Some(self.context.channel_type.clone()),
6981                 }
6982         }
6983
6984         // Message handlers
6985         pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, default_limits: &ChannelHandshakeLimits, their_features: &InitFeatures) -> Result<(), ChannelError> {
6986                 let peer_limits = if let Some(ref limits) = self.context.inbound_handshake_limits_override { limits } else { default_limits };
6987
6988                 // Check sanity of message fields:
6989                 if !self.context.is_outbound() {
6990                         return Err(ChannelError::Close("Got an accept_channel message from an inbound peer".to_owned()));
6991                 }
6992                 if !matches!(self.context.channel_state, ChannelState::NegotiatingFunding(flags) if flags == NegotiatingFundingFlags::OUR_INIT_SENT) {
6993                         return Err(ChannelError::Close("Got an accept_channel message at a strange time".to_owned()));
6994                 }
6995                 if msg.dust_limit_satoshis > 21000000 * 100000000 {
6996                         return Err(ChannelError::Close(format!("Peer never wants payout outputs? dust_limit_satoshis was {}", msg.dust_limit_satoshis)));
6997                 }
6998                 if msg.channel_reserve_satoshis > self.context.channel_value_satoshis {
6999                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.context.channel_value_satoshis)));
7000                 }
7001                 if msg.dust_limit_satoshis > self.context.holder_selected_channel_reserve_satoshis {
7002                         return Err(ChannelError::Close(format!("Dust limit ({}) is bigger than our channel reserve ({})", msg.dust_limit_satoshis, self.context.holder_selected_channel_reserve_satoshis)));
7003                 }
7004                 if msg.channel_reserve_satoshis > self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis {
7005                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than channel value minus our reserve ({})",
7006                                 msg.channel_reserve_satoshis, self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis)));
7007                 }
7008                 let full_channel_value_msat = (self.context.channel_value_satoshis - msg.channel_reserve_satoshis) * 1000;
7009                 if msg.htlc_minimum_msat >= full_channel_value_msat {
7010                         return Err(ChannelError::Close(format!("Minimum htlc value ({}) is full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
7011                 }
7012                 let max_delay_acceptable = u16::min(peer_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
7013                 if msg.to_self_delay > max_delay_acceptable {
7014                         return Err(ChannelError::Close(format!("They wanted our payments to be delayed by a needlessly long period. Upper limit: {}. Actual: {}", max_delay_acceptable, msg.to_self_delay)));
7015                 }
7016                 if msg.max_accepted_htlcs < 1 {
7017                         return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
7018                 }
7019                 if msg.max_accepted_htlcs > MAX_HTLCS {
7020                         return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
7021                 }
7022
7023                 // Now check against optional parameters as set by config...
7024                 if msg.htlc_minimum_msat > peer_limits.max_htlc_minimum_msat {
7025                         return Err(ChannelError::Close(format!("htlc_minimum_msat ({}) is higher than the user specified limit ({})", msg.htlc_minimum_msat, peer_limits.max_htlc_minimum_msat)));
7026                 }
7027                 if msg.max_htlc_value_in_flight_msat < peer_limits.min_max_htlc_value_in_flight_msat {
7028                         return Err(ChannelError::Close(format!("max_htlc_value_in_flight_msat ({}) is less than the user specified limit ({})", msg.max_htlc_value_in_flight_msat, peer_limits.min_max_htlc_value_in_flight_msat)));
7029                 }
7030                 if msg.channel_reserve_satoshis > peer_limits.max_channel_reserve_satoshis {
7031                         return Err(ChannelError::Close(format!("channel_reserve_satoshis ({}) is higher than the user specified limit ({})", msg.channel_reserve_satoshis, peer_limits.max_channel_reserve_satoshis)));
7032                 }
7033                 if msg.max_accepted_htlcs < peer_limits.min_max_accepted_htlcs {
7034                         return Err(ChannelError::Close(format!("max_accepted_htlcs ({}) is less than the user specified limit ({})", msg.max_accepted_htlcs, peer_limits.min_max_accepted_htlcs)));
7035                 }
7036                 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
7037                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
7038                 }
7039                 if msg.dust_limit_satoshis > MAX_CHAN_DUST_LIMIT_SATOSHIS {
7040                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
7041                 }
7042                 if msg.minimum_depth > peer_limits.max_minimum_depth {
7043                         return Err(ChannelError::Close(format!("We consider the minimum depth to be unreasonably large. Expected minimum: ({}). Actual: ({})", peer_limits.max_minimum_depth, msg.minimum_depth)));
7044                 }
7045
7046                 if let Some(ty) = &msg.channel_type {
7047                         if *ty != self.context.channel_type {
7048                                 return Err(ChannelError::Close("Channel Type in accept_channel didn't match the one sent in open_channel.".to_owned()));
7049                         }
7050                 } else if their_features.supports_channel_type() {
7051                         // Assume they've accepted the channel type as they said they understand it.
7052                 } else {
7053                         let channel_type = ChannelTypeFeatures::from_init(&their_features);
7054                         if channel_type != ChannelTypeFeatures::only_static_remote_key() {
7055                                 return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
7056                         }
7057                         self.context.channel_type = channel_type.clone();
7058                         self.context.channel_transaction_parameters.channel_type_features = channel_type;
7059                 }
7060
7061                 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
7062                         match &msg.shutdown_scriptpubkey {
7063                                 &Some(ref script) => {
7064                                         // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
7065                                         if script.len() == 0 {
7066                                                 None
7067                                         } else {
7068                                                 if !script::is_bolt2_compliant(&script, their_features) {
7069                                                         return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)));
7070                                                 }
7071                                                 Some(script.clone())
7072                                         }
7073                                 },
7074                                 // Peer is signaling upfront shutdown but don't opt-out with correct mechanism (a.k.a 0-length script). Peer looks buggy, we fail the channel
7075                                 &None => {
7076                                         return Err(ChannelError::Close("Peer is signaling upfront_shutdown but we don't get any script. Use 0-length script to opt-out".to_owned()));
7077                                 }
7078                         }
7079                 } else { None };
7080
7081                 self.context.counterparty_dust_limit_satoshis = msg.dust_limit_satoshis;
7082                 self.context.counterparty_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.context.channel_value_satoshis * 1000);
7083                 self.context.counterparty_selected_channel_reserve_satoshis = Some(msg.channel_reserve_satoshis);
7084                 self.context.counterparty_htlc_minimum_msat = msg.htlc_minimum_msat;
7085                 self.context.counterparty_max_accepted_htlcs = msg.max_accepted_htlcs;
7086
7087                 if peer_limits.trust_own_funding_0conf {
7088                         self.context.minimum_depth = Some(msg.minimum_depth);
7089                 } else {
7090                         self.context.minimum_depth = Some(cmp::max(1, msg.minimum_depth));
7091                 }
7092
7093                 let counterparty_pubkeys = ChannelPublicKeys {
7094                         funding_pubkey: msg.funding_pubkey,
7095                         revocation_basepoint: RevocationBasepoint::from(msg.revocation_basepoint),
7096                         payment_point: msg.payment_point,
7097                         delayed_payment_basepoint: DelayedPaymentBasepoint::from(msg.delayed_payment_basepoint),
7098                         htlc_basepoint: HtlcBasepoint::from(msg.htlc_basepoint)
7099                 };
7100
7101                 self.context.channel_transaction_parameters.counterparty_parameters = Some(CounterpartyChannelTransactionParameters {
7102                         selected_contest_delay: msg.to_self_delay,
7103                         pubkeys: counterparty_pubkeys,
7104                 });
7105
7106                 self.context.counterparty_cur_commitment_point = Some(msg.first_per_commitment_point);
7107                 self.context.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;
7108
7109                 self.context.channel_state = ChannelState::NegotiatingFunding(
7110                         NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT
7111                 );
7112                 self.context.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.
7113
7114                 Ok(())
7115         }
7116
7117         /// Handles a funding_signed message from the remote end.
7118         /// If this call is successful, broadcast the funding transaction (and not before!)
7119         pub fn funding_signed<L: Deref>(
7120                 mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
7121         ) -> Result<(Channel<SP>, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), (OutboundV1Channel<SP>, ChannelError)>
7122         where
7123                 L::Target: Logger
7124         {
7125                 if !self.context.is_outbound() {
7126                         return Err((self, ChannelError::Close("Received funding_signed for an inbound channel?".to_owned())));
7127                 }
7128                 if !matches!(self.context.channel_state, ChannelState::FundingNegotiated) {
7129                         return Err((self, ChannelError::Close("Received funding_signed in strange state!".to_owned())));
7130                 }
7131                 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
7132                                 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
7133                                 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
7134                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
7135                 }
7136
7137                 let funding_script = self.context.get_funding_redeemscript();
7138
7139                 let counterparty_keys = self.context.build_remote_transaction_keys();
7140                 let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
7141                 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
7142                 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
7143
7144                 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
7145                         &self.context.channel_id(), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
7146
7147                 let holder_signer = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
7148                 let initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &holder_signer, true, false, logger).tx;
7149                 {
7150                         let trusted_tx = initial_commitment_tx.trust();
7151                         let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
7152                         let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
7153                         // They sign our commitment transaction, allowing us to broadcast the tx if we wish.
7154                         if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.get_counterparty_pubkeys().funding_pubkey) {
7155                                 return Err((self, ChannelError::Close("Invalid funding_signed signature from peer".to_owned())));
7156                         }
7157                 }
7158
7159                 let holder_commitment_tx = HolderCommitmentTransaction::new(
7160                         initial_commitment_tx,
7161                         msg.signature,
7162                         Vec::new(),
7163                         &self.context.get_holder_pubkeys().funding_pubkey,
7164                         self.context.counterparty_funding_pubkey()
7165                 );
7166
7167                 let validated =
7168                         self.context.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, Vec::new());
7169                 if validated.is_err() {
7170                         return Err((self, ChannelError::Close("Failed to validate our commitment".to_owned())));
7171                 }
7172
7173                 let funding_redeemscript = self.context.get_funding_redeemscript();
7174                 let funding_txo = self.context.get_funding_txo().unwrap();
7175                 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
7176                 let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.context.get_holder_pubkeys().payment_point, &self.context.get_counterparty_pubkeys().payment_point, self.context.is_outbound());
7177                 let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
7178                 let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
7179                 monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
7180                 let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
7181                                                           shutdown_script, self.context.get_holder_selected_contest_delay(),
7182                                                           &self.context.destination_script, (funding_txo, funding_txo_script),
7183                                                           &self.context.channel_transaction_parameters,
7184                                                           funding_redeemscript.clone(), self.context.channel_value_satoshis,
7185                                                           obscure_factor,
7186                                                           holder_commitment_tx, best_block, self.context.counterparty_node_id, self.context.channel_id());
7187                 channel_monitor.provide_initial_counterparty_commitment_tx(
7188                         counterparty_initial_bitcoin_tx.txid, Vec::new(),
7189                         self.context.cur_counterparty_commitment_transaction_number,
7190                         self.context.counterparty_cur_commitment_point.unwrap(),
7191                         counterparty_initial_commitment_tx.feerate_per_kw(),
7192                         counterparty_initial_commitment_tx.to_broadcaster_value_sat(),
7193                         counterparty_initial_commitment_tx.to_countersignatory_value_sat(), logger);
7194
7195                 assert!(!self.context.channel_state.is_monitor_update_in_progress()); // We have no had any monitor(s) yet to fail update!
7196                 if self.context.is_batch_funding() {
7197                         self.context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH);
7198                 } else {
7199                         self.context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
7200                 }
7201                 self.context.cur_holder_commitment_transaction_number -= 1;
7202                 self.context.cur_counterparty_commitment_transaction_number -= 1;
7203
7204                 log_info!(logger, "Received funding_signed from peer for channel {}", &self.context.channel_id());
7205
7206                 let mut channel = Channel { context: self.context };
7207
7208                 let need_channel_ready = channel.check_get_channel_ready(0).is_some();
7209                 channel.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
7210                 Ok((channel, channel_monitor))
7211         }
7212
7213         /// Indicates that the signer may have some signatures for us, so we should retry if we're
7214         /// blocked.
7215         #[cfg(async_signing)]
7216         pub fn signer_maybe_unblocked<L: Deref>(&mut self, logger: &L) -> Option<msgs::FundingCreated> where L::Target: Logger {
7217                 if self.context.signer_pending_funding && self.context.is_outbound() {
7218                         log_trace!(logger, "Signer unblocked a funding_created");
7219                         self.get_funding_created_msg(logger)
7220                 } else { None }
7221         }
7222 }
7223
7224 /// A not-yet-funded inbound (from counterparty) channel using V1 channel establishment.
7225 pub(super) struct InboundV1Channel<SP: Deref> where SP::Target: SignerProvider {
7226         pub context: ChannelContext<SP>,
7227         pub unfunded_context: UnfundedChannelContext,
7228 }
7229
7230 /// Fetches the [`ChannelTypeFeatures`] that will be used for a channel built from a given
7231 /// [`msgs::OpenChannel`].
7232 pub(super) fn channel_type_from_open_channel(
7233         msg: &msgs::OpenChannel, their_features: &InitFeatures,
7234         our_supported_features: &ChannelTypeFeatures
7235 ) -> Result<ChannelTypeFeatures, ChannelError> {
7236         if let Some(channel_type) = &msg.channel_type {
7237                 if channel_type.supports_any_optional_bits() {
7238                         return Err(ChannelError::Close("Channel Type field contained optional bits - this is not allowed".to_owned()));
7239                 }
7240
7241                 // We only support the channel types defined by the `ChannelManager` in
7242                 // `provided_channel_type_features`. The channel type must always support
7243                 // `static_remote_key`.
7244                 if !channel_type.requires_static_remote_key() {
7245                         return Err(ChannelError::Close("Channel Type was not understood - we require static remote key".to_owned()));
7246                 }
7247                 // Make sure we support all of the features behind the channel type.
7248                 if !channel_type.is_subset(our_supported_features) {
7249                         return Err(ChannelError::Close("Channel Type contains unsupported features".to_owned()));
7250                 }
7251                 let announced_channel = if (msg.channel_flags & 1) == 1 { true } else { false };
7252                 if channel_type.requires_scid_privacy() && announced_channel {
7253                         return Err(ChannelError::Close("SCID Alias/Privacy Channel Type cannot be set on a public channel".to_owned()));
7254                 }
7255                 Ok(channel_type.clone())
7256         } else {
7257                 let channel_type = ChannelTypeFeatures::from_init(&their_features);
7258                 if channel_type != ChannelTypeFeatures::only_static_remote_key() {
7259                         return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
7260                 }
7261                 Ok(channel_type)
7262         }
7263 }
7264
7265 impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
7266         /// Creates a new channel from a remote sides' request for one.
7267         /// Assumes chain_hash has already been checked and corresponds with what we expect!
7268         pub fn new<ES: Deref, F: Deref, L: Deref>(
7269                 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
7270                 counterparty_node_id: PublicKey, our_supported_features: &ChannelTypeFeatures,
7271                 their_features: &InitFeatures, msg: &msgs::OpenChannel, user_id: u128, config: &UserConfig,
7272                 current_chain_height: u32, logger: &L, is_0conf: bool,
7273         ) -> Result<InboundV1Channel<SP>, ChannelError>
7274                 where ES::Target: EntropySource,
7275                           F::Target: FeeEstimator,
7276                           L::Target: Logger,
7277         {
7278                 let logger = WithContext::from(logger, Some(counterparty_node_id), Some(msg.temporary_channel_id));
7279                 let announced_channel = if (msg.channel_flags & 1) == 1 { true } else { false };
7280
7281                 // First check the channel type is known, failing before we do anything else if we don't
7282                 // support this channel type.
7283                 let channel_type = channel_type_from_open_channel(msg, their_features, our_supported_features)?;
7284
7285                 let channel_keys_id = signer_provider.generate_channel_keys_id(true, msg.funding_satoshis, user_id);
7286                 let holder_signer = signer_provider.derive_channel_signer(msg.funding_satoshis, channel_keys_id);
7287                 let pubkeys = holder_signer.pubkeys().clone();
7288                 let counterparty_pubkeys = ChannelPublicKeys {
7289                         funding_pubkey: msg.funding_pubkey,
7290                         revocation_basepoint: RevocationBasepoint::from(msg.revocation_basepoint),
7291                         payment_point: msg.payment_point,
7292                         delayed_payment_basepoint: DelayedPaymentBasepoint::from(msg.delayed_payment_basepoint),
7293                         htlc_basepoint: HtlcBasepoint::from(msg.htlc_basepoint)
7294                 };
7295
7296                 if config.channel_handshake_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
7297                         return Err(ChannelError::Close(format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks. It must be greater than {}", config.channel_handshake_config.our_to_self_delay, BREAKDOWN_TIMEOUT)));
7298                 }
7299
7300                 // Check sanity of message fields:
7301                 if msg.funding_satoshis > config.channel_handshake_limits.max_funding_satoshis {
7302                         return Err(ChannelError::Close(format!("Per our config, funding must be at most {}. It was {}", config.channel_handshake_limits.max_funding_satoshis, msg.funding_satoshis)));
7303                 }
7304                 if msg.funding_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
7305                         return Err(ChannelError::Close(format!("Funding must be smaller than the total bitcoin supply. It was {}", msg.funding_satoshis)));
7306                 }
7307                 if msg.channel_reserve_satoshis > msg.funding_satoshis {
7308                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must be not greater than funding_satoshis: {}", msg.channel_reserve_satoshis, msg.funding_satoshis)));
7309                 }
7310                 let full_channel_value_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000;
7311                 if msg.push_msat > full_channel_value_msat {
7312                         return Err(ChannelError::Close(format!("push_msat {} was larger than channel amount minus reserve ({})", msg.push_msat, full_channel_value_msat)));
7313                 }
7314                 if msg.dust_limit_satoshis > msg.funding_satoshis {
7315                         return Err(ChannelError::Close(format!("dust_limit_satoshis {} was larger than funding_satoshis {}. Peer never wants payout outputs?", msg.dust_limit_satoshis, msg.funding_satoshis)));
7316                 }
7317                 if msg.htlc_minimum_msat >= full_channel_value_msat {
7318                         return Err(ChannelError::Close(format!("Minimum htlc value ({}) was larger than full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
7319                 }
7320                 Channel::<SP>::check_remote_fee(&channel_type, fee_estimator, msg.feerate_per_kw, None, &&logger)?;
7321
7322                 let max_counterparty_selected_contest_delay = u16::min(config.channel_handshake_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
7323                 if msg.to_self_delay > max_counterparty_selected_contest_delay {
7324                         return Err(ChannelError::Close(format!("They wanted our payments to be delayed by a needlessly long period. Upper limit: {}. Actual: {}", max_counterparty_selected_contest_delay, msg.to_self_delay)));
7325                 }
7326                 if msg.max_accepted_htlcs < 1 {
7327                         return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
7328                 }
7329                 if msg.max_accepted_htlcs > MAX_HTLCS {
7330                         return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
7331                 }
7332
7333                 // Now check against optional parameters as set by config...
7334                 if msg.funding_satoshis < config.channel_handshake_limits.min_funding_satoshis {
7335                         return Err(ChannelError::Close(format!("Funding satoshis ({}) is less than the user specified limit ({})", msg.funding_satoshis, config.channel_handshake_limits.min_funding_satoshis)));
7336                 }
7337                 if msg.htlc_minimum_msat > config.channel_handshake_limits.max_htlc_minimum_msat {
7338                         return Err(ChannelError::Close(format!("htlc_minimum_msat ({}) is higher than the user specified limit ({})", msg.htlc_minimum_msat,  config.channel_handshake_limits.max_htlc_minimum_msat)));
7339                 }
7340                 if msg.max_htlc_value_in_flight_msat < config.channel_handshake_limits.min_max_htlc_value_in_flight_msat {
7341                         return Err(ChannelError::Close(format!("max_htlc_value_in_flight_msat ({}) is less than the user specified limit ({})", msg.max_htlc_value_in_flight_msat, config.channel_handshake_limits.min_max_htlc_value_in_flight_msat)));
7342                 }
7343                 if msg.channel_reserve_satoshis > config.channel_handshake_limits.max_channel_reserve_satoshis {
7344                         return Err(ChannelError::Close(format!("channel_reserve_satoshis ({}) is higher than the user specified limit ({})", msg.channel_reserve_satoshis, config.channel_handshake_limits.max_channel_reserve_satoshis)));
7345                 }
7346                 if msg.max_accepted_htlcs < config.channel_handshake_limits.min_max_accepted_htlcs {
7347                         return Err(ChannelError::Close(format!("max_accepted_htlcs ({}) is less than the user specified limit ({})", msg.max_accepted_htlcs, config.channel_handshake_limits.min_max_accepted_htlcs)));
7348                 }
7349                 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
7350                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
7351                 }
7352                 if msg.dust_limit_satoshis >  MAX_CHAN_DUST_LIMIT_SATOSHIS {
7353                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
7354                 }
7355
7356                 // Convert things into internal flags and prep our state:
7357
7358                 if config.channel_handshake_limits.force_announced_channel_preference {
7359                         if config.channel_handshake_config.announced_channel != announced_channel {
7360                                 return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours".to_owned()));
7361                         }
7362                 }
7363
7364                 let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(msg.funding_satoshis, config);
7365                 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
7366                         // Protocol level safety check in place, although it should never happen because
7367                         // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
7368                         return Err(ChannelError::Close(format!("Suitable channel reserve not found. remote_channel_reserve was ({}). dust_limit_satoshis is ({}).", holder_selected_channel_reserve_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
7369                 }
7370                 if holder_selected_channel_reserve_satoshis * 1000 >= full_channel_value_msat {
7371                         return Err(ChannelError::Close(format!("Suitable channel reserve not found. remote_channel_reserve was ({})msats. Channel value is ({} - {})msats.", holder_selected_channel_reserve_satoshis * 1000, full_channel_value_msat, msg.push_msat)));
7372                 }
7373                 if msg.channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
7374                         log_debug!(logger, "channel_reserve_satoshis ({}) is smaller than our dust limit ({}). We can broadcast stale states without any risk, implying this channel is very insecure for our counterparty.",
7375                                 msg.channel_reserve_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS);
7376                 }
7377                 if holder_selected_channel_reserve_satoshis < msg.dust_limit_satoshis {
7378                         return Err(ChannelError::Close(format!("Dust limit ({}) too high for the channel reserve we require the remote to keep ({})", msg.dust_limit_satoshis, holder_selected_channel_reserve_satoshis)));
7379                 }
7380
7381                 // check if the funder's amount for the initial commitment tx is sufficient
7382                 // for full fee payment plus a few HTLCs to ensure the channel will be useful.
7383                 let anchor_outputs_value = if channel_type.supports_anchors_zero_fee_htlc_tx() {
7384                         ANCHOR_OUTPUT_VALUE_SATOSHI * 2
7385                 } else {
7386                         0
7387                 };
7388                 let funders_amount_msat = msg.funding_satoshis * 1000 - msg.push_msat;
7389                 let commitment_tx_fee = commit_tx_fee_msat(msg.feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT, &channel_type) / 1000;
7390                 if (funders_amount_msat / 1000).saturating_sub(anchor_outputs_value) < commitment_tx_fee {
7391                         return Err(ChannelError::Close(format!("Funding amount ({} sats) can't even pay fee for initial commitment transaction fee of {} sats.", (funders_amount_msat / 1000).saturating_sub(anchor_outputs_value), commitment_tx_fee)));
7392                 }
7393
7394                 let to_remote_satoshis = funders_amount_msat / 1000 - commitment_tx_fee - anchor_outputs_value;
7395                 // While it's reasonable for us to not meet the channel reserve initially (if they don't
7396                 // want to push much to us), our counterparty should always have more than our reserve.
7397                 if to_remote_satoshis < holder_selected_channel_reserve_satoshis {
7398                         return Err(ChannelError::Close("Insufficient funding amount for initial reserve".to_owned()));
7399                 }
7400
7401                 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
7402                         match &msg.shutdown_scriptpubkey {
7403                                 &Some(ref script) => {
7404                                         // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
7405                                         if script.len() == 0 {
7406                                                 None
7407                                         } else {
7408                                                 if !script::is_bolt2_compliant(&script, their_features) {
7409                                                         return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)))
7410                                                 }
7411                                                 Some(script.clone())
7412                                         }
7413                                 },
7414                                 // Peer is signaling upfront shutdown but don't opt-out with correct mechanism (a.k.a 0-length script). Peer looks buggy, we fail the channel
7415                                 &None => {
7416                                         return Err(ChannelError::Close("Peer is signaling upfront_shutdown but we don't get any script. Use 0-length script to opt-out".to_owned()));
7417                                 }
7418                         }
7419                 } else { None };
7420
7421                 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
7422                         match signer_provider.get_shutdown_scriptpubkey() {
7423                                 Ok(scriptpubkey) => Some(scriptpubkey),
7424                                 Err(_) => return Err(ChannelError::Close("Failed to get upfront shutdown scriptpubkey".to_owned())),
7425                         }
7426                 } else { None };
7427
7428                 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
7429                         if !shutdown_scriptpubkey.is_compatible(&their_features) {
7430                                 return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
7431                         }
7432                 }
7433
7434                 let destination_script = match signer_provider.get_destination_script(channel_keys_id) {
7435                         Ok(script) => script,
7436                         Err(_) => return Err(ChannelError::Close("Failed to get destination script".to_owned())),
7437                 };
7438
7439                 let mut secp_ctx = Secp256k1::new();
7440                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
7441
7442                 let minimum_depth = if is_0conf {
7443                         Some(0)
7444                 } else {
7445                         Some(cmp::max(config.channel_handshake_config.minimum_depth, 1))
7446                 };
7447
7448                 let chan = Self {
7449                         context: ChannelContext {
7450                                 user_id,
7451
7452                                 config: LegacyChannelConfig {
7453                                         options: config.channel_config.clone(),
7454                                         announced_channel,
7455                                         commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
7456                                 },
7457
7458                                 prev_config: None,
7459
7460                                 inbound_handshake_limits_override: None,
7461
7462                                 temporary_channel_id: Some(msg.temporary_channel_id),
7463                                 channel_id: msg.temporary_channel_id,
7464                                 channel_state: ChannelState::NegotiatingFunding(
7465                                         NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT
7466                                 ),
7467                                 announcement_sigs_state: AnnouncementSigsState::NotSent,
7468                                 secp_ctx,
7469
7470                                 latest_monitor_update_id: 0,
7471
7472                                 holder_signer: ChannelSignerType::Ecdsa(holder_signer),
7473                                 shutdown_scriptpubkey,
7474                                 destination_script,
7475
7476                                 cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
7477                                 cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
7478                                 value_to_self_msat: msg.push_msat,
7479
7480                                 pending_inbound_htlcs: Vec::new(),
7481                                 pending_outbound_htlcs: Vec::new(),
7482                                 holding_cell_htlc_updates: Vec::new(),
7483                                 pending_update_fee: None,
7484                                 holding_cell_update_fee: None,
7485                                 next_holder_htlc_id: 0,
7486                                 next_counterparty_htlc_id: 0,
7487                                 update_time_counter: 1,
7488
7489                                 resend_order: RAACommitmentOrder::CommitmentFirst,
7490
7491                                 monitor_pending_channel_ready: false,
7492                                 monitor_pending_revoke_and_ack: false,
7493                                 monitor_pending_commitment_signed: false,
7494                                 monitor_pending_forwards: Vec::new(),
7495                                 monitor_pending_failures: Vec::new(),
7496                                 monitor_pending_finalized_fulfills: Vec::new(),
7497
7498                                 signer_pending_commitment_update: false,
7499                                 signer_pending_funding: false,
7500
7501                                 #[cfg(debug_assertions)]
7502                                 holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
7503                                 #[cfg(debug_assertions)]
7504                                 counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
7505
7506                                 last_sent_closing_fee: None,
7507                                 pending_counterparty_closing_signed: None,
7508                                 expecting_peer_commitment_signed: false,
7509                                 closing_fee_limits: None,
7510                                 target_closing_feerate_sats_per_kw: None,
7511
7512                                 funding_tx_confirmed_in: None,
7513                                 funding_tx_confirmation_height: 0,
7514                                 short_channel_id: None,
7515                                 channel_creation_height: current_chain_height,
7516
7517                                 feerate_per_kw: msg.feerate_per_kw,
7518                                 channel_value_satoshis: msg.funding_satoshis,
7519                                 counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
7520                                 holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
7521                                 counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
7522                                 holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(msg.funding_satoshis, &config.channel_handshake_config),
7523                                 counterparty_selected_channel_reserve_satoshis: Some(msg.channel_reserve_satoshis),
7524                                 holder_selected_channel_reserve_satoshis,
7525                                 counterparty_htlc_minimum_msat: msg.htlc_minimum_msat,
7526                                 holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
7527                                 counterparty_max_accepted_htlcs: msg.max_accepted_htlcs,
7528                                 holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
7529                                 minimum_depth,
7530
7531                                 counterparty_forwarding_info: None,
7532
7533                                 channel_transaction_parameters: ChannelTransactionParameters {
7534                                         holder_pubkeys: pubkeys,
7535                                         holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
7536                                         is_outbound_from_holder: false,
7537                                         counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
7538                                                 selected_contest_delay: msg.to_self_delay,
7539                                                 pubkeys: counterparty_pubkeys,
7540                                         }),
7541                                         funding_outpoint: None,
7542                                         channel_type_features: channel_type.clone()
7543                                 },
7544                                 funding_transaction: None,
7545                                 is_batch_funding: None,
7546
7547                                 counterparty_cur_commitment_point: Some(msg.first_per_commitment_point),
7548                                 counterparty_prev_commitment_point: None,
7549                                 counterparty_node_id,
7550
7551                                 counterparty_shutdown_scriptpubkey,
7552
7553                                 commitment_secrets: CounterpartyCommitmentSecrets::new(),
7554
7555                                 channel_update_status: ChannelUpdateStatus::Enabled,
7556                                 closing_signed_in_flight: false,
7557
7558                                 announcement_sigs: None,
7559
7560                                 #[cfg(any(test, fuzzing))]
7561                                 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
7562                                 #[cfg(any(test, fuzzing))]
7563                                 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
7564
7565                                 workaround_lnd_bug_4006: None,
7566                                 sent_message_awaiting_response: None,
7567
7568                                 latest_inbound_scid_alias: None,
7569                                 outbound_scid_alias: 0,
7570
7571                                 channel_pending_event_emitted: false,
7572                                 channel_ready_event_emitted: false,
7573
7574                                 #[cfg(any(test, fuzzing))]
7575                                 historical_inbound_htlc_fulfills: new_hash_set(),
7576
7577                                 channel_type,
7578                                 channel_keys_id,
7579
7580                                 local_initiated_shutdown: None,
7581
7582                                 blocked_monitor_updates: Vec::new(),
7583                         },
7584                         unfunded_context: UnfundedChannelContext { unfunded_channel_age_ticks: 0 }
7585                 };
7586
7587                 Ok(chan)
7588         }
7589
7590         /// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannel`] message which
7591         /// should be sent back to the counterparty node.
7592         ///
7593         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
7594         pub fn accept_inbound_channel(&mut self) -> msgs::AcceptChannel {
7595                 if self.context.is_outbound() {
7596                         panic!("Tried to send accept_channel for an outbound channel?");
7597                 }
7598                 if !matches!(
7599                         self.context.channel_state, ChannelState::NegotiatingFunding(flags)
7600                         if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
7601                 ) {
7602                         panic!("Tried to send accept_channel after channel had moved forward");
7603                 }
7604                 if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
7605                         panic!("Tried to send an accept_channel for a channel that has already advanced");
7606                 }
7607
7608                 self.generate_accept_channel_message()
7609         }
7610
7611         /// This function is used to explicitly generate a [`msgs::AcceptChannel`] message for an
7612         /// inbound channel. If the intention is to accept an inbound channel, use
7613         /// [`InboundV1Channel::accept_inbound_channel`] instead.
7614         ///
7615         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
7616         fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
7617                 let first_per_commitment_point = self.context.holder_signer.as_ref().get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
7618                 let keys = self.context.get_holder_pubkeys();
7619
7620                 msgs::AcceptChannel {
7621                         temporary_channel_id: self.context.channel_id,
7622                         dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
7623                         max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
7624                         channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
7625                         htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
7626                         minimum_depth: self.context.minimum_depth.unwrap(),
7627                         to_self_delay: self.context.get_holder_selected_contest_delay(),
7628                         max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
7629                         funding_pubkey: keys.funding_pubkey,
7630                         revocation_basepoint: keys.revocation_basepoint.to_public_key(),
7631                         payment_point: keys.payment_point,
7632                         delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
7633                         htlc_basepoint: keys.htlc_basepoint.to_public_key(),
7634                         first_per_commitment_point,
7635                         shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
7636                                 Some(script) => script.clone().into_inner(),
7637                                 None => Builder::new().into_script(),
7638                         }),
7639                         channel_type: Some(self.context.channel_type.clone()),
7640                         #[cfg(taproot)]
7641                         next_local_nonce: None,
7642                 }
7643         }
7644
7645         /// Enables the possibility for tests to extract a [`msgs::AcceptChannel`] message for an
7646         /// inbound channel without accepting it.
7647         ///
7648         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
7649         #[cfg(test)]
7650         pub fn get_accept_channel_message(&self) -> msgs::AcceptChannel {
7651                 self.generate_accept_channel_message()
7652         }
7653
7654         fn check_funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<CommitmentTransaction, ChannelError> where L::Target: Logger {
7655                 let funding_script = self.context.get_funding_redeemscript();
7656
7657                 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
7658                 let initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger).tx;
7659                 let trusted_tx = initial_commitment_tx.trust();
7660                 let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
7661                 let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
7662                 // They sign the holder commitment transaction...
7663                 log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} for channel {}.",
7664                         log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.context.counterparty_funding_pubkey().serialize()),
7665                         encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]),
7666                         encode::serialize_hex(&funding_script), &self.context.channel_id());
7667                 secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &sig, self.context.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
7668
7669                 Ok(initial_commitment_tx)
7670         }
7671
7672         pub fn funding_created<L: Deref>(
7673                 mut self, msg: &msgs::FundingCreated, best_block: BestBlock, signer_provider: &SP, logger: &L
7674         ) -> Result<(Channel<SP>, Option<msgs::FundingSigned>, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), (Self, ChannelError)>
7675         where
7676                 L::Target: Logger
7677         {
7678                 if self.context.is_outbound() {
7679                         return Err((self, ChannelError::Close("Received funding_created for an outbound channel?".to_owned())));
7680                 }
7681                 if !matches!(
7682                         self.context.channel_state, ChannelState::NegotiatingFunding(flags)
7683                         if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
7684                 ) {
7685                         // BOLT 2 says that if we disconnect before we send funding_signed we SHOULD NOT
7686                         // remember the channel, so it's safe to just send an error_message here and drop the
7687                         // channel.
7688                         return Err((self, ChannelError::Close("Received funding_created after we got the channel!".to_owned())));
7689                 }
7690                 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
7691                                 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
7692                                 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
7693                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
7694                 }
7695
7696                 let funding_txo = OutPoint { txid: msg.funding_txid, index: msg.funding_output_index };
7697                 self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
7698                 // This is an externally observable change before we finish all our checks.  In particular
7699                 // check_funding_created_signature may fail.
7700                 self.context.holder_signer.as_mut().provide_channel_parameters(&self.context.channel_transaction_parameters);
7701
7702                 let initial_commitment_tx = match self.check_funding_created_signature(&msg.signature, logger) {
7703                         Ok(res) => res,
7704                         Err(ChannelError::Close(e)) => {
7705                                 self.context.channel_transaction_parameters.funding_outpoint = None;
7706                                 return Err((self, ChannelError::Close(e)));
7707                         },
7708                         Err(e) => {
7709                                 // The only error we know how to handle is ChannelError::Close, so we fall over here
7710                                 // to make sure we don't continue with an inconsistent state.
7711                                 panic!("unexpected error type from check_funding_created_signature {:?}", e);
7712                         }
7713                 };
7714
7715                 let holder_commitment_tx = HolderCommitmentTransaction::new(
7716                         initial_commitment_tx,
7717                         msg.signature,
7718                         Vec::new(),
7719                         &self.context.get_holder_pubkeys().funding_pubkey,
7720                         self.context.counterparty_funding_pubkey()
7721                 );
7722
7723                 if let Err(_) = self.context.holder_signer.as_ref().validate_holder_commitment(&holder_commitment_tx, Vec::new()) {
7724                         return Err((self, ChannelError::Close("Failed to validate our commitment".to_owned())));
7725                 }
7726
7727                 // Now that we're past error-generating stuff, update our local state:
7728
7729                 self.context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
7730                 self.context.channel_id = ChannelId::v1_from_funding_outpoint(funding_txo);
7731                 self.context.cur_counterparty_commitment_transaction_number -= 1;
7732                 self.context.cur_holder_commitment_transaction_number -= 1;
7733
7734                 let (counterparty_initial_commitment_tx, funding_signed) = self.context.get_funding_signed_msg(logger);
7735
7736                 let funding_redeemscript = self.context.get_funding_redeemscript();
7737                 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
7738                 let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.context.get_holder_pubkeys().payment_point, &self.context.get_counterparty_pubkeys().payment_point, self.context.is_outbound());
7739                 let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
7740                 let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
7741                 monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
7742                 let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
7743                                                           shutdown_script, self.context.get_holder_selected_contest_delay(),
7744                                                           &self.context.destination_script, (funding_txo, funding_txo_script.clone()),
7745                                                           &self.context.channel_transaction_parameters,
7746                                                           funding_redeemscript.clone(), self.context.channel_value_satoshis,
7747                                                           obscure_factor,
7748                                                           holder_commitment_tx, best_block, self.context.counterparty_node_id, self.context.channel_id());
7749                 channel_monitor.provide_initial_counterparty_commitment_tx(
7750                         counterparty_initial_commitment_tx.trust().txid(), Vec::new(),
7751                         self.context.cur_counterparty_commitment_transaction_number + 1,
7752                         self.context.counterparty_cur_commitment_point.unwrap(), self.context.feerate_per_kw,
7753                         counterparty_initial_commitment_tx.to_broadcaster_value_sat(),
7754                         counterparty_initial_commitment_tx.to_countersignatory_value_sat(), logger);
7755
7756                 log_info!(logger, "{} funding_signed for peer for channel {}",
7757                         if funding_signed.is_some() { "Generated" } else { "Waiting for signature on" }, &self.context.channel_id());
7758
7759                 // Promote the channel to a full-fledged one now that we have updated the state and have a
7760                 // `ChannelMonitor`.
7761                 let mut channel = Channel {
7762                         context: self.context,
7763                 };
7764                 let need_channel_ready = channel.check_get_channel_ready(0).is_some();
7765                 channel.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
7766
7767                 Ok((channel, funding_signed, channel_monitor))
7768         }
7769 }
7770
7771 const SERIALIZATION_VERSION: u8 = 3;
7772 const MIN_SERIALIZATION_VERSION: u8 = 3;
7773
7774 impl_writeable_tlv_based_enum!(InboundHTLCRemovalReason,;
7775         (0, FailRelay),
7776         (1, FailMalformed),
7777         (2, Fulfill),
7778 );
7779
7780 impl Writeable for ChannelUpdateStatus {
7781         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
7782                 // We only care about writing out the current state as it was announced, ie only either
7783                 // Enabled or Disabled. In the case of DisabledStaged, we most recently announced the
7784                 // channel as enabled, so we write 0. For EnabledStaged, we similarly write a 1.
7785                 match self {
7786                         ChannelUpdateStatus::Enabled => 0u8.write(writer)?,
7787                         ChannelUpdateStatus::DisabledStaged(_) => 0u8.write(writer)?,
7788                         ChannelUpdateStatus::EnabledStaged(_) => 1u8.write(writer)?,
7789                         ChannelUpdateStatus::Disabled => 1u8.write(writer)?,
7790                 }
7791                 Ok(())
7792         }
7793 }
7794
7795 impl Readable for ChannelUpdateStatus {
7796         fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
7797                 Ok(match <u8 as Readable>::read(reader)? {
7798                         0 => ChannelUpdateStatus::Enabled,
7799                         1 => ChannelUpdateStatus::Disabled,
7800                         _ => return Err(DecodeError::InvalidValue),
7801                 })
7802         }
7803 }
7804
7805 impl Writeable for AnnouncementSigsState {
7806         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
7807                 // We only care about writing out the current state as if we had just disconnected, at
7808                 // which point we always set anything but AnnouncementSigsReceived to NotSent.
7809                 match self {
7810                         AnnouncementSigsState::NotSent => 0u8.write(writer),
7811                         AnnouncementSigsState::MessageSent => 0u8.write(writer),
7812                         AnnouncementSigsState::Committed => 0u8.write(writer),
7813                         AnnouncementSigsState::PeerReceived => 1u8.write(writer),
7814                 }
7815         }
7816 }
7817
7818 impl Readable for AnnouncementSigsState {
7819         fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
7820                 Ok(match <u8 as Readable>::read(reader)? {
7821                         0 => AnnouncementSigsState::NotSent,
7822                         1 => AnnouncementSigsState::PeerReceived,
7823                         _ => return Err(DecodeError::InvalidValue),
7824                 })
7825         }
7826 }
7827
7828 impl<SP: Deref> Writeable for Channel<SP> where SP::Target: SignerProvider {
7829         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
7830                 // Note that we write out as if remove_uncommitted_htlcs_and_mark_paused had just been
7831                 // called.
7832
7833                 write_ver_prefix!(writer, MIN_SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
7834
7835                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
7836                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We write
7837                 // the low bytes now and the optional high bytes later.
7838                 let user_id_low = self.context.user_id as u64;
7839                 user_id_low.write(writer)?;
7840
7841                 // Version 1 deserializers expected to read parts of the config object here. Version 2
7842                 // deserializers (0.0.99) now read config through TLVs, and as we now require them for
7843                 // `minimum_depth` we simply write dummy values here.
7844                 writer.write_all(&[0; 8])?;
7845
7846                 self.context.channel_id.write(writer)?;
7847                 {
7848                         let mut channel_state = self.context.channel_state;
7849                         if matches!(channel_state, ChannelState::AwaitingChannelReady(_)|ChannelState::ChannelReady(_)) {
7850                                 channel_state.set_peer_disconnected();
7851                         } else {
7852                                 debug_assert!(false, "Pre-funded/shutdown channels should not be written");
7853                         }
7854                         channel_state.to_u32().write(writer)?;
7855                 }
7856                 self.context.channel_value_satoshis.write(writer)?;
7857
7858                 self.context.latest_monitor_update_id.write(writer)?;
7859
7860                 // Write out the old serialization for shutdown_pubkey for backwards compatibility, if
7861                 // deserialized from that format.
7862                 match self.context.shutdown_scriptpubkey.as_ref().and_then(|script| script.as_legacy_pubkey()) {
7863                         Some(shutdown_pubkey) => shutdown_pubkey.write(writer)?,
7864                         None => [0u8; PUBLIC_KEY_SIZE].write(writer)?,
7865                 }
7866                 self.context.destination_script.write(writer)?;
7867
7868                 self.context.cur_holder_commitment_transaction_number.write(writer)?;
7869                 self.context.cur_counterparty_commitment_transaction_number.write(writer)?;
7870                 self.context.value_to_self_msat.write(writer)?;
7871
7872                 let mut dropped_inbound_htlcs = 0;
7873                 for htlc in self.context.pending_inbound_htlcs.iter() {
7874                         if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
7875                                 dropped_inbound_htlcs += 1;
7876                         }
7877                 }
7878                 (self.context.pending_inbound_htlcs.len() as u64 - dropped_inbound_htlcs).write(writer)?;
7879                 for htlc in self.context.pending_inbound_htlcs.iter() {
7880                         if let &InboundHTLCState::RemoteAnnounced(_) = &htlc.state {
7881                                 continue; // Drop
7882                         }
7883                         htlc.htlc_id.write(writer)?;
7884                         htlc.amount_msat.write(writer)?;
7885                         htlc.cltv_expiry.write(writer)?;
7886                         htlc.payment_hash.write(writer)?;
7887                         match &htlc.state {
7888                                 &InboundHTLCState::RemoteAnnounced(_) => unreachable!(),
7889                                 &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref htlc_state) => {
7890                                         1u8.write(writer)?;
7891                                         htlc_state.write(writer)?;
7892                                 },
7893                                 &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(ref htlc_state) => {
7894                                         2u8.write(writer)?;
7895                                         htlc_state.write(writer)?;
7896                                 },
7897                                 &InboundHTLCState::Committed => {
7898                                         3u8.write(writer)?;
7899                                 },
7900                                 &InboundHTLCState::LocalRemoved(ref removal_reason) => {
7901                                         4u8.write(writer)?;
7902                                         removal_reason.write(writer)?;
7903                                 },
7904                         }
7905                 }
7906
7907                 let mut preimages: Vec<&Option<PaymentPreimage>> = vec![];
7908                 let mut pending_outbound_skimmed_fees: Vec<Option<u64>> = Vec::new();
7909                 let mut pending_outbound_blinding_points: Vec<Option<PublicKey>> = Vec::new();
7910
7911                 (self.context.pending_outbound_htlcs.len() as u64).write(writer)?;
7912                 for htlc in self.context.pending_outbound_htlcs.iter() {
7913                         htlc.htlc_id.write(writer)?;
7914                         htlc.amount_msat.write(writer)?;
7915                         htlc.cltv_expiry.write(writer)?;
7916                         htlc.payment_hash.write(writer)?;
7917                         htlc.source.write(writer)?;
7918                         match &htlc.state {
7919                                 &OutboundHTLCState::LocalAnnounced(ref onion_packet) => {
7920                                         0u8.write(writer)?;
7921                                         onion_packet.write(writer)?;
7922                                 },
7923                                 &OutboundHTLCState::Committed => {
7924                                         1u8.write(writer)?;
7925                                 },
7926                                 &OutboundHTLCState::RemoteRemoved(_) => {
7927                                         // Treat this as a Committed because we haven't received the CS - they'll
7928                                         // resend the claim/fail on reconnect as we all (hopefully) the missing CS.
7929                                         1u8.write(writer)?;
7930                                 },
7931                                 &OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref outcome) => {
7932                                         3u8.write(writer)?;
7933                                         if let OutboundHTLCOutcome::Success(preimage) = outcome {
7934                                                 preimages.push(preimage);
7935                                         }
7936                                         let reason: Option<&HTLCFailReason> = outcome.into();
7937                                         reason.write(writer)?;
7938                                 }
7939                                 &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) => {
7940                                         4u8.write(writer)?;
7941                                         if let OutboundHTLCOutcome::Success(preimage) = outcome {
7942                                                 preimages.push(preimage);
7943                                         }
7944                                         let reason: Option<&HTLCFailReason> = outcome.into();
7945                                         reason.write(writer)?;
7946                                 }
7947                         }
7948                         pending_outbound_skimmed_fees.push(htlc.skimmed_fee_msat);
7949                         pending_outbound_blinding_points.push(htlc.blinding_point);
7950                 }
7951
7952                 let mut holding_cell_skimmed_fees: Vec<Option<u64>> = Vec::new();
7953                 let mut holding_cell_blinding_points: Vec<Option<PublicKey>> = Vec::new();
7954                 // Vec of (htlc_id, failure_code, sha256_of_onion)
7955                 let mut malformed_htlcs: Vec<(u64, u16, [u8; 32])> = Vec::new();
7956                 (self.context.holding_cell_htlc_updates.len() as u64).write(writer)?;
7957                 for update in self.context.holding_cell_htlc_updates.iter() {
7958                         match update {
7959                                 &HTLCUpdateAwaitingACK::AddHTLC {
7960                                         ref amount_msat, ref cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet,
7961                                         blinding_point, skimmed_fee_msat,
7962                                 } => {
7963                                         0u8.write(writer)?;
7964                                         amount_msat.write(writer)?;
7965                                         cltv_expiry.write(writer)?;
7966                                         payment_hash.write(writer)?;
7967                                         source.write(writer)?;
7968                                         onion_routing_packet.write(writer)?;
7969
7970                                         holding_cell_skimmed_fees.push(skimmed_fee_msat);
7971                                         holding_cell_blinding_points.push(blinding_point);
7972                                 },
7973                                 &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, ref htlc_id } => {
7974                                         1u8.write(writer)?;
7975                                         payment_preimage.write(writer)?;
7976                                         htlc_id.write(writer)?;
7977                                 },
7978                                 &HTLCUpdateAwaitingACK::FailHTLC { ref htlc_id, ref err_packet } => {
7979                                         2u8.write(writer)?;
7980                                         htlc_id.write(writer)?;
7981                                         err_packet.write(writer)?;
7982                                 }
7983                                 &HTLCUpdateAwaitingACK::FailMalformedHTLC {
7984                                         htlc_id, failure_code, sha256_of_onion
7985                                 } => {
7986                                         // We don't want to break downgrading by adding a new variant, so write a dummy
7987                                         // `::FailHTLC` variant and write the real malformed error as an optional TLV.
7988                                         malformed_htlcs.push((htlc_id, failure_code, sha256_of_onion));
7989
7990                                         let dummy_err_packet = msgs::OnionErrorPacket { data: Vec::new() };
7991                                         2u8.write(writer)?;
7992                                         htlc_id.write(writer)?;
7993                                         dummy_err_packet.write(writer)?;
7994                                 }
7995                         }
7996                 }
7997
7998                 match self.context.resend_order {
7999                         RAACommitmentOrder::CommitmentFirst => 0u8.write(writer)?,
8000                         RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
8001                 }
8002
8003                 self.context.monitor_pending_channel_ready.write(writer)?;
8004                 self.context.monitor_pending_revoke_and_ack.write(writer)?;
8005                 self.context.monitor_pending_commitment_signed.write(writer)?;
8006
8007                 (self.context.monitor_pending_forwards.len() as u64).write(writer)?;
8008                 for &(ref pending_forward, ref htlc_id) in self.context.monitor_pending_forwards.iter() {
8009                         pending_forward.write(writer)?;
8010                         htlc_id.write(writer)?;
8011                 }
8012
8013                 (self.context.monitor_pending_failures.len() as u64).write(writer)?;
8014                 for &(ref htlc_source, ref payment_hash, ref fail_reason) in self.context.monitor_pending_failures.iter() {
8015                         htlc_source.write(writer)?;
8016                         payment_hash.write(writer)?;
8017                         fail_reason.write(writer)?;
8018                 }
8019
8020                 if self.context.is_outbound() {
8021                         self.context.pending_update_fee.map(|(a, _)| a).write(writer)?;
8022                 } else if let Some((feerate, FeeUpdateState::AwaitingRemoteRevokeToAnnounce)) = self.context.pending_update_fee {
8023                         Some(feerate).write(writer)?;
8024                 } else {
8025                         // As for inbound HTLCs, if the update was only announced and never committed in a
8026                         // commitment_signed, drop it.
8027                         None::<u32>.write(writer)?;
8028                 }
8029                 self.context.holding_cell_update_fee.write(writer)?;
8030
8031                 self.context.next_holder_htlc_id.write(writer)?;
8032                 (self.context.next_counterparty_htlc_id - dropped_inbound_htlcs).write(writer)?;
8033                 self.context.update_time_counter.write(writer)?;
8034                 self.context.feerate_per_kw.write(writer)?;
8035
8036                 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
8037                 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
8038                 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
8039                 // consider the stale state on reload.
8040                 0u8.write(writer)?;
8041
8042                 self.context.funding_tx_confirmed_in.write(writer)?;
8043                 self.context.funding_tx_confirmation_height.write(writer)?;
8044                 self.context.short_channel_id.write(writer)?;
8045
8046                 self.context.counterparty_dust_limit_satoshis.write(writer)?;
8047                 self.context.holder_dust_limit_satoshis.write(writer)?;
8048                 self.context.counterparty_max_htlc_value_in_flight_msat.write(writer)?;
8049
8050                 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
8051                 self.context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;
8052
8053                 self.context.counterparty_htlc_minimum_msat.write(writer)?;
8054                 self.context.holder_htlc_minimum_msat.write(writer)?;
8055                 self.context.counterparty_max_accepted_htlcs.write(writer)?;
8056
8057                 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
8058                 self.context.minimum_depth.unwrap_or(0).write(writer)?;
8059
8060                 match &self.context.counterparty_forwarding_info {
8061                         Some(info) => {
8062                                 1u8.write(writer)?;
8063                                 info.fee_base_msat.write(writer)?;
8064                                 info.fee_proportional_millionths.write(writer)?;
8065                                 info.cltv_expiry_delta.write(writer)?;
8066                         },
8067                         None => 0u8.write(writer)?
8068                 }
8069
8070                 self.context.channel_transaction_parameters.write(writer)?;
8071                 self.context.funding_transaction.write(writer)?;
8072
8073                 self.context.counterparty_cur_commitment_point.write(writer)?;
8074                 self.context.counterparty_prev_commitment_point.write(writer)?;
8075                 self.context.counterparty_node_id.write(writer)?;
8076
8077                 self.context.counterparty_shutdown_scriptpubkey.write(writer)?;
8078
8079                 self.context.commitment_secrets.write(writer)?;
8080
8081                 self.context.channel_update_status.write(writer)?;
8082
8083                 #[cfg(any(test, fuzzing))]
8084                 (self.context.historical_inbound_htlc_fulfills.len() as u64).write(writer)?;
8085                 #[cfg(any(test, fuzzing))]
8086                 for htlc in self.context.historical_inbound_htlc_fulfills.iter() {
8087                         htlc.write(writer)?;
8088                 }
8089
8090                 // If the channel type is something other than only-static-remote-key, then we need to have
8091                 // older clients fail to deserialize this channel at all. If the type is
8092                 // only-static-remote-key, we simply consider it "default" and don't write the channel type
8093                 // out at all.
8094                 let chan_type = if self.context.channel_type != ChannelTypeFeatures::only_static_remote_key() {
8095                         Some(&self.context.channel_type) } else { None };
8096
8097                 // The same logic applies for `holder_selected_channel_reserve_satoshis` values other than
8098                 // the default, and when `holder_max_htlc_value_in_flight_msat` is configured to be set to
8099                 // a different percentage of the channel value then 10%, which older versions of LDK used
8100                 // to set it to before the percentage was made configurable.
8101                 let serialized_holder_selected_reserve =
8102                         if self.context.holder_selected_channel_reserve_satoshis != get_legacy_default_holder_selected_channel_reserve_satoshis(self.context.channel_value_satoshis)
8103                         { Some(self.context.holder_selected_channel_reserve_satoshis) } else { None };
8104
8105                 let mut old_max_in_flight_percent_config = UserConfig::default().channel_handshake_config;
8106                 old_max_in_flight_percent_config.max_inbound_htlc_value_in_flight_percent_of_channel = MAX_IN_FLIGHT_PERCENT_LEGACY;
8107                 let serialized_holder_htlc_max_in_flight =
8108                         if self.context.holder_max_htlc_value_in_flight_msat != get_holder_max_htlc_value_in_flight_msat(self.context.channel_value_satoshis, &old_max_in_flight_percent_config)
8109                         { Some(self.context.holder_max_htlc_value_in_flight_msat) } else { None };
8110
8111                 let channel_pending_event_emitted = Some(self.context.channel_pending_event_emitted);
8112                 let channel_ready_event_emitted = Some(self.context.channel_ready_event_emitted);
8113
8114                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
8115                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. Therefore,
8116                 // we write the high bytes as an option here.
8117                 let user_id_high_opt = Some((self.context.user_id >> 64) as u64);
8118
8119                 let holder_max_accepted_htlcs = if self.context.holder_max_accepted_htlcs == DEFAULT_MAX_HTLCS { None } else { Some(self.context.holder_max_accepted_htlcs) };
8120
8121                 write_tlv_fields!(writer, {
8122                         (0, self.context.announcement_sigs, option),
8123                         // minimum_depth and counterparty_selected_channel_reserve_satoshis used to have a
8124                         // default value instead of being Option<>al. Thus, to maintain compatibility we write
8125                         // them twice, once with their original default values above, and once as an option
8126                         // here. On the read side, old versions will simply ignore the odd-type entries here,
8127                         // and new versions map the default values to None and allow the TLV entries here to
8128                         // override that.
8129                         (1, self.context.minimum_depth, option),
8130                         (2, chan_type, option),
8131                         (3, self.context.counterparty_selected_channel_reserve_satoshis, option),
8132                         (4, serialized_holder_selected_reserve, option),
8133                         (5, self.context.config, required),
8134                         (6, serialized_holder_htlc_max_in_flight, option),
8135                         (7, self.context.shutdown_scriptpubkey, option),
8136                         (8, self.context.blocked_monitor_updates, optional_vec),
8137                         (9, self.context.target_closing_feerate_sats_per_kw, option),
8138                         (11, self.context.monitor_pending_finalized_fulfills, required_vec),
8139                         (13, self.context.channel_creation_height, required),
8140                         (15, preimages, required_vec),
8141                         (17, self.context.announcement_sigs_state, required),
8142                         (19, self.context.latest_inbound_scid_alias, option),
8143                         (21, self.context.outbound_scid_alias, required),
8144                         (23, channel_ready_event_emitted, option),
8145                         (25, user_id_high_opt, option),
8146                         (27, self.context.channel_keys_id, required),
8147                         (28, holder_max_accepted_htlcs, option),
8148                         (29, self.context.temporary_channel_id, option),
8149                         (31, channel_pending_event_emitted, option),
8150                         (35, pending_outbound_skimmed_fees, optional_vec),
8151                         (37, holding_cell_skimmed_fees, optional_vec),
8152                         (38, self.context.is_batch_funding, option),
8153                         (39, pending_outbound_blinding_points, optional_vec),
8154                         (41, holding_cell_blinding_points, optional_vec),
8155                         (43, malformed_htlcs, optional_vec), // Added in 0.0.119
8156                         (45, self.context.local_initiated_shutdown, option), // Added in 0.0.122
8157                 });
8158
8159                 Ok(())
8160         }
8161 }
8162
8163 const MAX_ALLOC_SIZE: usize = 64*1024;
8164 impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)> for Channel<SP>
8165                 where
8166                         ES::Target: EntropySource,
8167                         SP::Target: SignerProvider
8168 {
8169         fn read<R : io::Read>(reader: &mut R, args: (&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)) -> Result<Self, DecodeError> {
8170                 let (entropy_source, signer_provider, serialized_height, our_supported_features) = args;
8171                 let ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
8172
8173                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
8174                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We read
8175                 // the low bytes now and the high bytes later.
8176                 let user_id_low: u64 = Readable::read(reader)?;
8177
8178                 let mut config = Some(LegacyChannelConfig::default());
8179                 if ver == 1 {
8180                         // Read the old serialization of the ChannelConfig from version 0.0.98.
8181                         config.as_mut().unwrap().options.forwarding_fee_proportional_millionths = Readable::read(reader)?;
8182                         config.as_mut().unwrap().options.cltv_expiry_delta = Readable::read(reader)?;
8183                         config.as_mut().unwrap().announced_channel = Readable::read(reader)?;
8184                         config.as_mut().unwrap().commit_upfront_shutdown_pubkey = Readable::read(reader)?;
8185                 } else {
8186                         // Read the 8 bytes of backwards-compatibility ChannelConfig data.
8187                         let mut _val: u64 = Readable::read(reader)?;
8188                 }
8189
8190                 let channel_id = Readable::read(reader)?;
8191                 let channel_state = ChannelState::from_u32(Readable::read(reader)?).map_err(|_| DecodeError::InvalidValue)?;
8192                 let channel_value_satoshis = Readable::read(reader)?;
8193
8194                 let latest_monitor_update_id = Readable::read(reader)?;
8195
8196                 let mut keys_data = None;
8197                 if ver <= 2 {
8198                         // Read the serialize signer bytes. We'll choose to deserialize them or not based on whether
8199                         // the `channel_keys_id` TLV is present below.
8200                         let keys_len: u32 = Readable::read(reader)?;
8201                         keys_data = Some(Vec::with_capacity(cmp::min(keys_len as usize, MAX_ALLOC_SIZE)));
8202                         while keys_data.as_ref().unwrap().len() != keys_len as usize {
8203                                 // Read 1KB at a time to avoid accidentally allocating 4GB on corrupted channel keys
8204                                 let mut data = [0; 1024];
8205                                 let read_slice = &mut data[0..cmp::min(1024, keys_len as usize - keys_data.as_ref().unwrap().len())];
8206                                 reader.read_exact(read_slice)?;
8207                                 keys_data.as_mut().unwrap().extend_from_slice(read_slice);
8208                         }
8209                 }
8210
8211                 // Read the old serialization for shutdown_pubkey, preferring the TLV field later if set.
8212                 let mut shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
8213                         Ok(pubkey) => Some(ShutdownScript::new_p2wpkh_from_pubkey(pubkey)),
8214                         Err(_) => None,
8215                 };
8216                 let destination_script = Readable::read(reader)?;
8217
8218                 let cur_holder_commitment_transaction_number = Readable::read(reader)?;
8219                 let cur_counterparty_commitment_transaction_number = Readable::read(reader)?;
8220                 let value_to_self_msat = Readable::read(reader)?;
8221
8222                 let pending_inbound_htlc_count: u64 = Readable::read(reader)?;
8223
8224                 let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(pending_inbound_htlc_count as usize, DEFAULT_MAX_HTLCS as usize));
8225                 for _ in 0..pending_inbound_htlc_count {
8226                         pending_inbound_htlcs.push(InboundHTLCOutput {
8227                                 htlc_id: Readable::read(reader)?,
8228                                 amount_msat: Readable::read(reader)?,
8229                                 cltv_expiry: Readable::read(reader)?,
8230                                 payment_hash: Readable::read(reader)?,
8231                                 state: match <u8 as Readable>::read(reader)? {
8232                                         1 => InboundHTLCState::AwaitingRemoteRevokeToAnnounce(Readable::read(reader)?),
8233                                         2 => InboundHTLCState::AwaitingAnnouncedRemoteRevoke(Readable::read(reader)?),
8234                                         3 => InboundHTLCState::Committed,
8235                                         4 => InboundHTLCState::LocalRemoved(Readable::read(reader)?),
8236                                         _ => return Err(DecodeError::InvalidValue),
8237                                 },
8238                         });
8239                 }
8240
8241                 let pending_outbound_htlc_count: u64 = Readable::read(reader)?;
8242                 let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(pending_outbound_htlc_count as usize, DEFAULT_MAX_HTLCS as usize));
8243                 for _ in 0..pending_outbound_htlc_count {
8244                         pending_outbound_htlcs.push(OutboundHTLCOutput {
8245                                 htlc_id: Readable::read(reader)?,
8246                                 amount_msat: Readable::read(reader)?,
8247                                 cltv_expiry: Readable::read(reader)?,
8248                                 payment_hash: Readable::read(reader)?,
8249                                 source: Readable::read(reader)?,
8250                                 state: match <u8 as Readable>::read(reader)? {
8251                                         0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
8252                                         1 => OutboundHTLCState::Committed,
8253                                         2 => {
8254                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
8255                                                 OutboundHTLCState::RemoteRemoved(option.into())
8256                                         },
8257                                         3 => {
8258                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
8259                                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(option.into())
8260                                         },
8261                                         4 => {
8262                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
8263                                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(option.into())
8264                                         },
8265                                         _ => return Err(DecodeError::InvalidValue),
8266                                 },
8267                                 skimmed_fee_msat: None,
8268                                 blinding_point: None,
8269                         });
8270                 }
8271
8272                 let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
8273                 let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, DEFAULT_MAX_HTLCS as usize*2));
8274                 for _ in 0..holding_cell_htlc_update_count {
8275                         holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
8276                                 0 => HTLCUpdateAwaitingACK::AddHTLC {
8277                                         amount_msat: Readable::read(reader)?,
8278                                         cltv_expiry: Readable::read(reader)?,
8279                                         payment_hash: Readable::read(reader)?,
8280                                         source: Readable::read(reader)?,
8281                                         onion_routing_packet: Readable::read(reader)?,
8282                                         skimmed_fee_msat: None,
8283                                         blinding_point: None,
8284                                 },
8285                                 1 => HTLCUpdateAwaitingACK::ClaimHTLC {
8286                                         payment_preimage: Readable::read(reader)?,
8287                                         htlc_id: Readable::read(reader)?,
8288                                 },
8289                                 2 => HTLCUpdateAwaitingACK::FailHTLC {
8290                                         htlc_id: Readable::read(reader)?,
8291                                         err_packet: Readable::read(reader)?,
8292                                 },
8293                                 _ => return Err(DecodeError::InvalidValue),
8294                         });
8295                 }
8296
8297                 let resend_order = match <u8 as Readable>::read(reader)? {
8298                         0 => RAACommitmentOrder::CommitmentFirst,
8299                         1 => RAACommitmentOrder::RevokeAndACKFirst,
8300                         _ => return Err(DecodeError::InvalidValue),
8301                 };
8302
8303                 let monitor_pending_channel_ready = Readable::read(reader)?;
8304                 let monitor_pending_revoke_and_ack = Readable::read(reader)?;
8305                 let monitor_pending_commitment_signed = Readable::read(reader)?;
8306
8307                 let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
8308                 let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, DEFAULT_MAX_HTLCS as usize));
8309                 for _ in 0..monitor_pending_forwards_count {
8310                         monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
8311                 }
8312
8313                 let monitor_pending_failures_count: u64 = Readable::read(reader)?;
8314                 let mut monitor_pending_failures = Vec::with_capacity(cmp::min(monitor_pending_failures_count as usize, DEFAULT_MAX_HTLCS as usize));
8315                 for _ in 0..monitor_pending_failures_count {
8316                         monitor_pending_failures.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
8317                 }
8318
8319                 let pending_update_fee_value: Option<u32> = Readable::read(reader)?;
8320
8321                 let holding_cell_update_fee = Readable::read(reader)?;
8322
8323                 let next_holder_htlc_id = Readable::read(reader)?;
8324                 let next_counterparty_htlc_id = Readable::read(reader)?;
8325                 let update_time_counter = Readable::read(reader)?;
8326                 let feerate_per_kw = Readable::read(reader)?;
8327
8328                 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
8329                 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
8330                 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
8331                 // consider the stale state on reload.
8332                 match <u8 as Readable>::read(reader)? {
8333                         0 => {},
8334                         1 => {
8335                                 let _: u32 = Readable::read(reader)?;
8336                                 let _: u64 = Readable::read(reader)?;
8337                                 let _: Signature = Readable::read(reader)?;
8338                         },
8339                         _ => return Err(DecodeError::InvalidValue),
8340                 }
8341
8342                 let funding_tx_confirmed_in = Readable::read(reader)?;
8343                 let funding_tx_confirmation_height = Readable::read(reader)?;
8344                 let short_channel_id = Readable::read(reader)?;
8345
8346                 let counterparty_dust_limit_satoshis = Readable::read(reader)?;
8347                 let holder_dust_limit_satoshis = Readable::read(reader)?;
8348                 let counterparty_max_htlc_value_in_flight_msat = Readable::read(reader)?;
8349                 let mut counterparty_selected_channel_reserve_satoshis = None;
8350                 if ver == 1 {
8351                         // Read the old serialization from version 0.0.98.
8352                         counterparty_selected_channel_reserve_satoshis = Some(Readable::read(reader)?);
8353                 } else {
8354                         // Read the 8 bytes of backwards-compatibility data.
8355                         let _dummy: u64 = Readable::read(reader)?;
8356                 }
8357                 let counterparty_htlc_minimum_msat = Readable::read(reader)?;
8358                 let holder_htlc_minimum_msat = Readable::read(reader)?;
8359                 let counterparty_max_accepted_htlcs = Readable::read(reader)?;
8360
8361                 let mut minimum_depth = None;
8362                 if ver == 1 {
8363                         // Read the old serialization from version 0.0.98.
8364                         minimum_depth = Some(Readable::read(reader)?);
8365                 } else {
8366                         // Read the 4 bytes of backwards-compatibility data.
8367                         let _dummy: u32 = Readable::read(reader)?;
8368                 }
8369
8370                 let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
8371                         0 => None,
8372                         1 => Some(CounterpartyForwardingInfo {
8373                                 fee_base_msat: Readable::read(reader)?,
8374                                 fee_proportional_millionths: Readable::read(reader)?,
8375                                 cltv_expiry_delta: Readable::read(reader)?,
8376                         }),
8377                         _ => return Err(DecodeError::InvalidValue),
8378                 };
8379
8380                 let mut channel_parameters: ChannelTransactionParameters = Readable::read(reader)?;
8381                 let funding_transaction: Option<Transaction> = Readable::read(reader)?;
8382
8383                 let counterparty_cur_commitment_point = Readable::read(reader)?;
8384
8385                 let counterparty_prev_commitment_point = Readable::read(reader)?;
8386                 let counterparty_node_id = Readable::read(reader)?;
8387
8388                 let counterparty_shutdown_scriptpubkey = Readable::read(reader)?;
8389                 let commitment_secrets = Readable::read(reader)?;
8390
8391                 let channel_update_status = Readable::read(reader)?;
8392
8393                 #[cfg(any(test, fuzzing))]
8394                 let mut historical_inbound_htlc_fulfills = new_hash_set();
8395                 #[cfg(any(test, fuzzing))]
8396                 {
8397                         let htlc_fulfills_len: u64 = Readable::read(reader)?;
8398                         for _ in 0..htlc_fulfills_len {
8399                                 assert!(historical_inbound_htlc_fulfills.insert(Readable::read(reader)?));
8400                         }
8401                 }
8402
8403                 let pending_update_fee = if let Some(feerate) = pending_update_fee_value {
8404                         Some((feerate, if channel_parameters.is_outbound_from_holder {
8405                                 FeeUpdateState::Outbound
8406                         } else {
8407                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce
8408                         }))
8409                 } else {
8410                         None
8411                 };
8412
8413                 let mut announcement_sigs = None;
8414                 let mut target_closing_feerate_sats_per_kw = None;
8415                 let mut monitor_pending_finalized_fulfills = Some(Vec::new());
8416                 let mut holder_selected_channel_reserve_satoshis = Some(get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis));
8417                 let mut holder_max_htlc_value_in_flight_msat = Some(get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &UserConfig::default().channel_handshake_config));
8418                 // Prior to supporting channel type negotiation, all of our channels were static_remotekey
8419                 // only, so we default to that if none was written.
8420                 let mut channel_type = Some(ChannelTypeFeatures::only_static_remote_key());
8421                 let mut channel_creation_height = Some(serialized_height);
8422                 let mut preimages_opt: Option<Vec<Option<PaymentPreimage>>> = None;
8423
8424                 // If we read an old Channel, for simplicity we just treat it as "we never sent an
8425                 // AnnouncementSignatures" which implies we'll re-send it on reconnect, but that's fine.
8426                 let mut announcement_sigs_state = Some(AnnouncementSigsState::NotSent);
8427                 let mut latest_inbound_scid_alias = None;
8428                 let mut outbound_scid_alias = None;
8429                 let mut channel_pending_event_emitted = None;
8430                 let mut channel_ready_event_emitted = None;
8431
8432                 let mut user_id_high_opt: Option<u64> = None;
8433                 let mut channel_keys_id: Option<[u8; 32]> = None;
8434                 let mut temporary_channel_id: Option<ChannelId> = None;
8435                 let mut holder_max_accepted_htlcs: Option<u16> = None;
8436
8437                 let mut blocked_monitor_updates = Some(Vec::new());
8438
8439                 let mut pending_outbound_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;
8440                 let mut holding_cell_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;
8441
8442                 let mut is_batch_funding: Option<()> = None;
8443
8444                 let mut local_initiated_shutdown: Option<()> = None;
8445
8446                 let mut pending_outbound_blinding_points_opt: Option<Vec<Option<PublicKey>>> = None;
8447                 let mut holding_cell_blinding_points_opt: Option<Vec<Option<PublicKey>>> = None;
8448
8449                 let mut malformed_htlcs: Option<Vec<(u64, u16, [u8; 32])>> = None;
8450
8451                 read_tlv_fields!(reader, {
8452                         (0, announcement_sigs, option),
8453                         (1, minimum_depth, option),
8454                         (2, channel_type, option),
8455                         (3, counterparty_selected_channel_reserve_satoshis, option),
8456                         (4, holder_selected_channel_reserve_satoshis, option),
8457                         (5, config, option), // Note that if none is provided we will *not* overwrite the existing one.
8458                         (6, holder_max_htlc_value_in_flight_msat, option),
8459                         (7, shutdown_scriptpubkey, option),
8460                         (8, blocked_monitor_updates, optional_vec),
8461                         (9, target_closing_feerate_sats_per_kw, option),
8462                         (11, monitor_pending_finalized_fulfills, optional_vec),
8463                         (13, channel_creation_height, option),
8464                         (15, preimages_opt, optional_vec),
8465                         (17, announcement_sigs_state, option),
8466                         (19, latest_inbound_scid_alias, option),
8467                         (21, outbound_scid_alias, option),
8468                         (23, channel_ready_event_emitted, option),
8469                         (25, user_id_high_opt, option),
8470                         (27, channel_keys_id, option),
8471                         (28, holder_max_accepted_htlcs, option),
8472                         (29, temporary_channel_id, option),
8473                         (31, channel_pending_event_emitted, option),
8474                         (35, pending_outbound_skimmed_fees_opt, optional_vec),
8475                         (37, holding_cell_skimmed_fees_opt, optional_vec),
8476                         (38, is_batch_funding, option),
8477                         (39, pending_outbound_blinding_points_opt, optional_vec),
8478                         (41, holding_cell_blinding_points_opt, optional_vec),
8479                         (43, malformed_htlcs, optional_vec), // Added in 0.0.119
8480                         (45, local_initiated_shutdown, option),
8481                 });
8482
8483                 let (channel_keys_id, holder_signer) = if let Some(channel_keys_id) = channel_keys_id {
8484                         let mut holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
8485                         // If we've gotten to the funding stage of the channel, populate the signer with its
8486                         // required channel parameters.
8487                         if channel_state >= ChannelState::FundingNegotiated {
8488                                 holder_signer.provide_channel_parameters(&channel_parameters);
8489                         }
8490                         (channel_keys_id, holder_signer)
8491                 } else {
8492                         // `keys_data` can be `None` if we had corrupted data.
8493                         let keys_data = keys_data.ok_or(DecodeError::InvalidValue)?;
8494                         let holder_signer = signer_provider.read_chan_signer(&keys_data)?;
8495                         (holder_signer.channel_keys_id(), holder_signer)
8496                 };
8497
8498                 if let Some(preimages) = preimages_opt {
8499                         let mut iter = preimages.into_iter();
8500                         for htlc in pending_outbound_htlcs.iter_mut() {
8501                                 match &htlc.state {
8502                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(None)) => {
8503                                                 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
8504                                         }
8505                                         OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(None)) => {
8506                                                 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
8507                                         }
8508                                         _ => {}
8509                                 }
8510                         }
8511                         // We expect all preimages to be consumed above
8512                         if iter.next().is_some() {
8513                                 return Err(DecodeError::InvalidValue);
8514                         }
8515                 }
8516
8517                 let chan_features = channel_type.as_ref().unwrap();
8518                 if !chan_features.is_subset(our_supported_features) {
8519                         // If the channel was written by a new version and negotiated with features we don't
8520                         // understand yet, refuse to read it.
8521                         return Err(DecodeError::UnknownRequiredFeature);
8522                 }
8523
8524                 // ChannelTransactionParameters may have had an empty features set upon deserialization.
8525                 // To account for that, we're proactively setting/overriding the field here.
8526                 channel_parameters.channel_type_features = chan_features.clone();
8527
8528                 let mut secp_ctx = Secp256k1::new();
8529                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
8530
8531                 // `user_id` used to be a single u64 value. In order to remain backwards
8532                 // compatible with versions prior to 0.0.113, the u128 is serialized as two
8533                 // separate u64 values.
8534                 let user_id = user_id_low as u128 + ((user_id_high_opt.unwrap_or(0) as u128) << 64);
8535
8536                 let holder_max_accepted_htlcs = holder_max_accepted_htlcs.unwrap_or(DEFAULT_MAX_HTLCS);
8537
8538                 if let Some(skimmed_fees) = pending_outbound_skimmed_fees_opt {
8539                         let mut iter = skimmed_fees.into_iter();
8540                         for htlc in pending_outbound_htlcs.iter_mut() {
8541                                 htlc.skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
8542                         }
8543                         // We expect all skimmed fees to be consumed above
8544                         if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
8545                 }
8546                 if let Some(skimmed_fees) = holding_cell_skimmed_fees_opt {
8547                         let mut iter = skimmed_fees.into_iter();
8548                         for htlc in holding_cell_htlc_updates.iter_mut() {
8549                                 if let HTLCUpdateAwaitingACK::AddHTLC { ref mut skimmed_fee_msat, .. } = htlc {
8550                                         *skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
8551                                 }
8552                         }
8553                         // We expect all skimmed fees to be consumed above
8554                         if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
8555                 }
8556                 if let Some(blinding_pts) = pending_outbound_blinding_points_opt {
8557                         let mut iter = blinding_pts.into_iter();
8558                         for htlc in pending_outbound_htlcs.iter_mut() {
8559                                 htlc.blinding_point = iter.next().ok_or(DecodeError::InvalidValue)?;
8560                         }
8561                         // We expect all blinding points to be consumed above
8562                         if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
8563                 }
8564                 if let Some(blinding_pts) = holding_cell_blinding_points_opt {
8565                         let mut iter = blinding_pts.into_iter();
8566                         for htlc in holding_cell_htlc_updates.iter_mut() {
8567                                 if let HTLCUpdateAwaitingACK::AddHTLC { ref mut blinding_point, .. } = htlc {
8568                                         *blinding_point = iter.next().ok_or(DecodeError::InvalidValue)?;
8569                                 }
8570                         }
8571                         // We expect all blinding points to be consumed above
8572                         if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
8573                 }
8574
8575                 if let Some(malformed_htlcs) = malformed_htlcs {
8576                         for (malformed_htlc_id, failure_code, sha256_of_onion) in malformed_htlcs {
8577                                 let htlc_idx = holding_cell_htlc_updates.iter().position(|htlc| {
8578                                         if let HTLCUpdateAwaitingACK::FailHTLC { htlc_id, err_packet } = htlc {
8579                                                 let matches = *htlc_id == malformed_htlc_id;
8580                                                 if matches { debug_assert!(err_packet.data.is_empty()) }
8581                                                 matches
8582                                         } else { false }
8583                                 }).ok_or(DecodeError::InvalidValue)?;
8584                                 let malformed_htlc = HTLCUpdateAwaitingACK::FailMalformedHTLC {
8585                                         htlc_id: malformed_htlc_id, failure_code, sha256_of_onion
8586                                 };
8587                                 let _ = core::mem::replace(&mut holding_cell_htlc_updates[htlc_idx], malformed_htlc);
8588                         }
8589                 }
8590
8591                 Ok(Channel {
8592                         context: ChannelContext {
8593                                 user_id,
8594
8595                                 config: config.unwrap(),
8596
8597                                 prev_config: None,
8598
8599                                 // Note that we don't care about serializing handshake limits as we only ever serialize
8600                                 // channel data after the handshake has completed.
8601                                 inbound_handshake_limits_override: None,
8602
8603                                 channel_id,
8604                                 temporary_channel_id,
8605                                 channel_state,
8606                                 announcement_sigs_state: announcement_sigs_state.unwrap(),
8607                                 secp_ctx,
8608                                 channel_value_satoshis,
8609
8610                                 latest_monitor_update_id,
8611
8612                                 holder_signer: ChannelSignerType::Ecdsa(holder_signer),
8613                                 shutdown_scriptpubkey,
8614                                 destination_script,
8615
8616                                 cur_holder_commitment_transaction_number,
8617                                 cur_counterparty_commitment_transaction_number,
8618                                 value_to_self_msat,
8619
8620                                 holder_max_accepted_htlcs,
8621                                 pending_inbound_htlcs,
8622                                 pending_outbound_htlcs,
8623                                 holding_cell_htlc_updates,
8624
8625                                 resend_order,
8626
8627                                 monitor_pending_channel_ready,
8628                                 monitor_pending_revoke_and_ack,
8629                                 monitor_pending_commitment_signed,
8630                                 monitor_pending_forwards,
8631                                 monitor_pending_failures,
8632                                 monitor_pending_finalized_fulfills: monitor_pending_finalized_fulfills.unwrap(),
8633
8634                                 signer_pending_commitment_update: false,
8635                                 signer_pending_funding: false,
8636
8637                                 pending_update_fee,
8638                                 holding_cell_update_fee,
8639                                 next_holder_htlc_id,
8640                                 next_counterparty_htlc_id,
8641                                 update_time_counter,
8642                                 feerate_per_kw,
8643
8644                                 #[cfg(debug_assertions)]
8645                                 holder_max_commitment_tx_output: Mutex::new((0, 0)),
8646                                 #[cfg(debug_assertions)]
8647                                 counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
8648
8649                                 last_sent_closing_fee: None,
8650                                 pending_counterparty_closing_signed: None,
8651                                 expecting_peer_commitment_signed: false,
8652                                 closing_fee_limits: None,
8653                                 target_closing_feerate_sats_per_kw,
8654
8655                                 funding_tx_confirmed_in,
8656                                 funding_tx_confirmation_height,
8657                                 short_channel_id,
8658                                 channel_creation_height: channel_creation_height.unwrap(),
8659
8660                                 counterparty_dust_limit_satoshis,
8661                                 holder_dust_limit_satoshis,
8662                                 counterparty_max_htlc_value_in_flight_msat,
8663                                 holder_max_htlc_value_in_flight_msat: holder_max_htlc_value_in_flight_msat.unwrap(),
8664                                 counterparty_selected_channel_reserve_satoshis,
8665                                 holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.unwrap(),
8666                                 counterparty_htlc_minimum_msat,
8667                                 holder_htlc_minimum_msat,
8668                                 counterparty_max_accepted_htlcs,
8669                                 minimum_depth,
8670
8671                                 counterparty_forwarding_info,
8672
8673                                 channel_transaction_parameters: channel_parameters,
8674                                 funding_transaction,
8675                                 is_batch_funding,
8676
8677                                 counterparty_cur_commitment_point,
8678                                 counterparty_prev_commitment_point,
8679                                 counterparty_node_id,
8680
8681                                 counterparty_shutdown_scriptpubkey,
8682
8683                                 commitment_secrets,
8684
8685                                 channel_update_status,
8686                                 closing_signed_in_flight: false,
8687
8688                                 announcement_sigs,
8689
8690                                 #[cfg(any(test, fuzzing))]
8691                                 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
8692                                 #[cfg(any(test, fuzzing))]
8693                                 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
8694
8695                                 workaround_lnd_bug_4006: None,
8696                                 sent_message_awaiting_response: None,
8697
8698                                 latest_inbound_scid_alias,
8699                                 // Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
8700                                 outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
8701
8702                                 channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
8703                                 channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
8704
8705                                 #[cfg(any(test, fuzzing))]
8706                                 historical_inbound_htlc_fulfills,
8707
8708                                 channel_type: channel_type.unwrap(),
8709                                 channel_keys_id,
8710
8711                                 local_initiated_shutdown,
8712
8713                                 blocked_monitor_updates: blocked_monitor_updates.unwrap(),
8714                         }
8715                 })
8716         }
8717 }
8718
8719 #[cfg(test)]
8720 mod tests {
8721         use std::cmp;
8722         use bitcoin::blockdata::constants::ChainHash;
8723         use bitcoin::blockdata::script::{ScriptBuf, Builder};
8724         use bitcoin::blockdata::transaction::{Transaction, TxOut};
8725         use bitcoin::blockdata::opcodes;
8726         use bitcoin::network::constants::Network;
8727         use crate::ln::onion_utils::INVALID_ONION_BLINDING;
8728         use crate::ln::{PaymentHash, PaymentPreimage};
8729         use crate::ln::channel_keys::{RevocationKey, RevocationBasepoint};
8730         use crate::ln::channelmanager::{self, HTLCSource, PaymentId};
8731         use crate::ln::channel::InitFeatures;
8732         use crate::ln::channel::{AwaitingChannelReadyFlags, Channel, ChannelState, InboundHTLCOutput, OutboundV1Channel, InboundV1Channel, OutboundHTLCOutput, InboundHTLCState, OutboundHTLCState, HTLCCandidate, HTLCInitiator, HTLCUpdateAwaitingACK, commit_tx_fee_msat};
8733         use crate::ln::channel::{MAX_FUNDING_SATOSHIS_NO_WUMBO, TOTAL_BITCOIN_SUPPLY_SATOSHIS, MIN_THEIR_CHAN_RESERVE_SATOSHIS};
8734         use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, NodeFeatures};
8735         use crate::ln::msgs;
8736         use crate::ln::msgs::{ChannelUpdate, DecodeError, UnsignedChannelUpdate, MAX_VALUE_MSAT};
8737         use crate::ln::script::ShutdownScript;
8738         use crate::ln::chan_utils::{self, htlc_success_tx_weight, htlc_timeout_tx_weight};
8739         use crate::chain::BestBlock;
8740         use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
8741         use crate::sign::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
8742         use crate::chain::transaction::OutPoint;
8743         use crate::routing::router::{Path, RouteHop};
8744         use crate::util::config::UserConfig;
8745         use crate::util::errors::APIError;
8746         use crate::util::ser::{ReadableArgs, Writeable};
8747         use crate::util::test_utils;
8748         use crate::util::test_utils::{OnGetShutdownScriptpubkey, TestKeysInterface};
8749         use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
8750         use bitcoin::secp256k1::ffi::Signature as FFISignature;
8751         use bitcoin::secp256k1::{SecretKey,PublicKey};
8752         use bitcoin::hashes::sha256::Hash as Sha256;
8753         use bitcoin::hashes::Hash;
8754         use bitcoin::hashes::hex::FromHex;
8755         use bitcoin::hash_types::WPubkeyHash;
8756         use bitcoin::blockdata::locktime::absolute::LockTime;
8757         use bitcoin::address::{WitnessProgram, WitnessVersion};
8758         use crate::prelude::*;
8759
8760         #[test]
8761         fn test_channel_state_order() {
8762                 use crate::ln::channel::NegotiatingFundingFlags;
8763                 use crate::ln::channel::AwaitingChannelReadyFlags;
8764                 use crate::ln::channel::ChannelReadyFlags;
8765
8766                 assert!(ChannelState::NegotiatingFunding(NegotiatingFundingFlags::new()) < ChannelState::FundingNegotiated);
8767                 assert!(ChannelState::FundingNegotiated < ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()));
8768                 assert!(ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()) < ChannelState::ChannelReady(ChannelReadyFlags::new()));
8769                 assert!(ChannelState::ChannelReady(ChannelReadyFlags::new()) < ChannelState::ShutdownComplete);
8770         }
8771
8772         struct TestFeeEstimator {
8773                 fee_est: u32
8774         }
8775         impl FeeEstimator for TestFeeEstimator {
8776                 fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
8777                         self.fee_est
8778                 }
8779         }
8780
8781         #[test]
8782         fn test_max_funding_satoshis_no_wumbo() {
8783                 assert_eq!(TOTAL_BITCOIN_SUPPLY_SATOSHIS, 21_000_000 * 100_000_000);
8784                 assert!(MAX_FUNDING_SATOSHIS_NO_WUMBO <= TOTAL_BITCOIN_SUPPLY_SATOSHIS,
8785                         "MAX_FUNDING_SATOSHIS_NO_WUMBO is greater than all satoshis in existence");
8786         }
8787
8788         struct Keys {
8789                 signer: InMemorySigner,
8790         }
8791
8792         impl EntropySource for Keys {
8793                 fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }
8794         }
8795
8796         impl SignerProvider for Keys {
8797                 type EcdsaSigner = InMemorySigner;
8798                 #[cfg(taproot)]
8799                 type TaprootSigner = InMemorySigner;
8800
8801                 fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
8802                         self.signer.channel_keys_id()
8803                 }
8804
8805                 fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
8806                         self.signer.clone()
8807                 }
8808
8809                 fn read_chan_signer(&self, _data: &[u8]) -> Result<Self::EcdsaSigner, DecodeError> { panic!(); }
8810
8811                 fn get_destination_script(&self, _channel_keys_id: [u8; 32]) -> Result<ScriptBuf, ()> {
8812                         let secp_ctx = Secp256k1::signing_only();
8813                         let channel_monitor_claim_key = SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
8814                         let channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
8815                         Ok(Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(channel_monitor_claim_key_hash).into_script())
8816                 }
8817
8818                 fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()> {
8819                         let secp_ctx = Secp256k1::signing_only();
8820                         let channel_close_key = SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
8821                         Ok(ShutdownScript::new_p2wpkh_from_pubkey(PublicKey::from_secret_key(&secp_ctx, &channel_close_key)))
8822                 }
8823         }
8824
8825         #[cfg(all(feature = "_test_vectors", not(feature = "grind_signatures")))]
8826         fn public_from_secret_hex(secp_ctx: &Secp256k1<bitcoin::secp256k1::All>, hex: &str) -> PublicKey {
8827                 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&<Vec<u8>>::from_hex(hex).unwrap()[..]).unwrap())
8828         }
8829
8830         #[test]
8831         fn upfront_shutdown_script_incompatibility() {
8832                 let features = channelmanager::provided_init_features(&UserConfig::default()).clear_shutdown_anysegwit();
8833                 let non_v0_segwit_shutdown_script = ShutdownScript::new_witness_program(
8834                         &WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(),
8835                 ).unwrap();
8836
8837                 let seed = [42; 32];
8838                 let network = Network::Testnet;
8839                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8840                 keys_provider.expect(OnGetShutdownScriptpubkey {
8841                         returns: non_v0_segwit_shutdown_script.clone(),
8842                 });
8843
8844                 let secp_ctx = Secp256k1::new();
8845                 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8846                 let config = UserConfig::default();
8847                 match OutboundV1Channel::<&TestKeysInterface>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 253 }), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42, None) {
8848                         Err(APIError::IncompatibleShutdownScript { script }) => {
8849                                 assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
8850                         },
8851                         Err(e) => panic!("Unexpected error: {:?}", e),
8852                         Ok(_) => panic!("Expected error"),
8853                 }
8854         }
8855
8856         // Check that, during channel creation, we use the same feerate in the open channel message
8857         // as we do in the Channel object creation itself.
8858         #[test]
8859         fn test_open_channel_msg_fee() {
8860                 let original_fee = 253;
8861                 let mut fee_est = TestFeeEstimator{fee_est: original_fee };
8862                 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
8863                 let secp_ctx = Secp256k1::new();
8864                 let seed = [42; 32];
8865                 let network = Network::Testnet;
8866                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8867
8868                 let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8869                 let config = UserConfig::default();
8870                 let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&bounded_fee_estimator, &&keys_provider, &&keys_provider, node_a_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
8871
8872                 // Now change the fee so we can check that the fee in the open_channel message is the
8873                 // same as the old fee.
8874                 fee_est.fee_est = 500;
8875                 let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
8876                 assert_eq!(open_channel_msg.feerate_per_kw, original_fee);
8877         }
8878
8879         #[test]
8880         fn test_holder_vs_counterparty_dust_limit() {
8881                 // Test that when calculating the local and remote commitment transaction fees, the correct
8882                 // dust limits are used.
8883                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8884                 let secp_ctx = Secp256k1::new();
8885                 let seed = [42; 32];
8886                 let network = Network::Testnet;
8887                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8888                 let logger = test_utils::TestLogger::new();
8889                 let best_block = BestBlock::from_network(network);
8890
8891                 // Go through the flow of opening a channel between two nodes, making sure
8892                 // they have different dust limits.
8893
8894                 // Create Node A's channel pointing to Node B's pubkey
8895                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8896                 let config = UserConfig::default();
8897                 let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
8898
8899                 // Create Node B's channel by receiving Node A's open_channel message
8900                 // Make sure A's dust limit is as we expect.
8901                 let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
8902                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
8903                 let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
8904
8905                 // Node B --> Node A: accept channel, explicitly setting B's dust limit.
8906                 let mut accept_channel_msg = node_b_chan.accept_inbound_channel();
8907                 accept_channel_msg.dust_limit_satoshis = 546;
8908                 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
8909                 node_a_chan.context.holder_dust_limit_satoshis = 1560;
8910
8911                 // Node A --> Node B: funding created
8912                 let output_script = node_a_chan.context.get_funding_redeemscript();
8913                 let tx = Transaction { version: 1, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
8914                         value: 10000000, script_pubkey: output_script.clone(),
8915                 }]};
8916                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
8917                 let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
8918                 let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
8919
8920                 // Node B --> Node A: funding signed
8921                 let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
8922                 let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };
8923
8924                 // Put some inbound and outbound HTLCs in A's channel.
8925                 let htlc_amount_msat = 11_092_000; // put an amount below A's effective dust limit but above B's.
8926                 node_a_chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
8927                         htlc_id: 0,
8928                         amount_msat: htlc_amount_msat,
8929                         payment_hash: PaymentHash(Sha256::hash(&[42; 32]).to_byte_array()),
8930                         cltv_expiry: 300000000,
8931                         state: InboundHTLCState::Committed,
8932                 });
8933
8934                 node_a_chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
8935                         htlc_id: 1,
8936                         amount_msat: htlc_amount_msat, // put an amount below A's dust amount but above B's.
8937                         payment_hash: PaymentHash(Sha256::hash(&[43; 32]).to_byte_array()),
8938                         cltv_expiry: 200000000,
8939                         state: OutboundHTLCState::Committed,
8940                         source: HTLCSource::OutboundRoute {
8941                                 path: Path { hops: Vec::new(), blinded_tail: None },
8942                                 session_priv: SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
8943                                 first_hop_htlc_msat: 548,
8944                                 payment_id: PaymentId([42; 32]),
8945                         },
8946                         skimmed_fee_msat: None,
8947                         blinding_point: None,
8948                 });
8949
8950                 // Make sure when Node A calculates their local commitment transaction, none of the HTLCs pass
8951                 // the dust limit check.
8952                 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
8953                 let local_commit_tx_fee = node_a_chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
8954                 let local_commit_fee_0_htlcs = commit_tx_fee_msat(node_a_chan.context.feerate_per_kw, 0, node_a_chan.context.get_channel_type());
8955                 assert_eq!(local_commit_tx_fee, local_commit_fee_0_htlcs);
8956
8957                 // Finally, make sure that when Node A calculates the remote's commitment transaction fees, all
8958                 // of the HTLCs are seen to be above the dust limit.
8959                 node_a_chan.context.channel_transaction_parameters.is_outbound_from_holder = false;
8960                 let remote_commit_fee_3_htlcs = commit_tx_fee_msat(node_a_chan.context.feerate_per_kw, 3, node_a_chan.context.get_channel_type());
8961                 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
8962                 let remote_commit_tx_fee = node_a_chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
8963                 assert_eq!(remote_commit_tx_fee, remote_commit_fee_3_htlcs);
8964         }
8965
8966         #[test]
8967         fn test_timeout_vs_success_htlc_dust_limit() {
8968                 // Make sure that when `next_remote_commit_tx_fee_msat` and `next_local_commit_tx_fee_msat`
8969                 // calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
8970                 // *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
8971                 // `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
8972                 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 253 });
8973                 let secp_ctx = Secp256k1::new();
8974                 let seed = [42; 32];
8975                 let network = Network::Testnet;
8976                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8977
8978                 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8979                 let config = UserConfig::default();
8980                 let mut chan = OutboundV1Channel::<&TestKeysInterface>::new(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
8981
8982                 let commitment_tx_fee_0_htlcs = commit_tx_fee_msat(chan.context.feerate_per_kw, 0, chan.context.get_channel_type());
8983                 let commitment_tx_fee_1_htlc = commit_tx_fee_msat(chan.context.feerate_per_kw, 1, chan.context.get_channel_type());
8984
8985                 // If HTLC_SUCCESS_TX_WEIGHT and HTLC_TIMEOUT_TX_WEIGHT were swapped: then this HTLC would be
8986                 // counted as dust when it shouldn't be.
8987                 let htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.holder_dust_limit_satoshis + 1) * 1000;
8988                 let htlc_candidate = HTLCCandidate::new(htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
8989                 let commitment_tx_fee = chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
8990                 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
8991
8992                 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
8993                 let dust_htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.holder_dust_limit_satoshis - 1) * 1000;
8994                 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_below_success, HTLCInitiator::RemoteOffered);
8995                 let commitment_tx_fee = chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
8996                 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
8997
8998                 chan.context.channel_transaction_parameters.is_outbound_from_holder = false;
8999
9000                 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
9001                 let dust_htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.counterparty_dust_limit_satoshis + 1) * 1000;
9002                 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
9003                 let commitment_tx_fee = chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
9004                 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
9005
9006                 // If swapped: this HTLC would be counted as dust when it shouldn't be.
9007                 let htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.counterparty_dust_limit_satoshis - 1) * 1000;
9008                 let htlc_candidate = HTLCCandidate::new(htlc_amt_below_success, HTLCInitiator::RemoteOffered);
9009                 let commitment_tx_fee = chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
9010                 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
9011         }
9012
9013         #[test]
9014         fn channel_reestablish_no_updates() {
9015                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
9016                 let logger = test_utils::TestLogger::new();
9017                 let secp_ctx = Secp256k1::new();
9018                 let seed = [42; 32];
9019                 let network = Network::Testnet;
9020                 let best_block = BestBlock::from_network(network);
9021                 let chain_hash = ChainHash::using_genesis_block(network);
9022                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
9023
9024                 // Go through the flow of opening a channel between two nodes.
9025
9026                 // Create Node A's channel pointing to Node B's pubkey
9027                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9028                 let config = UserConfig::default();
9029                 let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
9030
9031                 // Create Node B's channel by receiving Node A's open_channel message
9032                 let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
9033                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9034                 let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
9035
9036                 // Node B --> Node A: accept channel
9037                 let accept_channel_msg = node_b_chan.accept_inbound_channel();
9038                 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
9039
9040                 // Node A --> Node B: funding created
9041                 let output_script = node_a_chan.context.get_funding_redeemscript();
9042                 let tx = Transaction { version: 1, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
9043                         value: 10000000, script_pubkey: output_script.clone(),
9044                 }]};
9045                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
9046                 let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
9047                 let (mut node_b_chan, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
9048
9049                 // Node B --> Node A: funding signed
9050                 let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
9051                 let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };
9052
9053                 // Now disconnect the two nodes and check that the commitment point in
9054                 // Node B's channel_reestablish message is sane.
9055                 assert!(node_b_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger).is_ok());
9056                 let msg = node_b_chan.get_channel_reestablish(&&logger);
9057                 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
9058                 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
9059                 assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);
9060
9061                 // Check that the commitment point in Node A's channel_reestablish message
9062                 // is sane.
9063                 assert!(node_a_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger).is_ok());
9064                 let msg = node_a_chan.get_channel_reestablish(&&logger);
9065                 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
9066                 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
9067                 assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);
9068         }
9069
9070         #[test]
9071         fn test_configured_holder_max_htlc_value_in_flight() {
9072                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
9073                 let logger = test_utils::TestLogger::new();
9074                 let secp_ctx = Secp256k1::new();
9075                 let seed = [42; 32];
9076                 let network = Network::Testnet;
9077                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
9078                 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9079                 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9080
9081                 let mut config_2_percent = UserConfig::default();
9082                 config_2_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 2;
9083                 let mut config_99_percent = UserConfig::default();
9084                 config_99_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 99;
9085                 let mut config_0_percent = UserConfig::default();
9086                 config_0_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 0;
9087                 let mut config_101_percent = UserConfig::default();
9088                 config_101_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 101;
9089
9090                 // Test that `OutboundV1Channel::new` creates a channel with the correct value for
9091                 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
9092                 // which is set to the lower bound + 1 (2%) of the `channel_value`.
9093                 let chan_1 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42, None).unwrap();
9094                 let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
9095                 assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
9096
9097                 // Test with the upper bound - 1 of valid values (99%).
9098                 let chan_2 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42, None).unwrap();
9099                 let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
9100                 assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
9101
9102                 let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network));
9103
9104                 // Test that `InboundV1Channel::new` creates a channel with the correct value for
9105                 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
9106                 // which is set to the lower bound - 1 (2%) of the `channel_value`.
9107                 let chan_3 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_2_percent), &channelmanager::provided_init_features(&config_2_percent), &chan_1_open_channel_msg, 7, &config_2_percent, 0, &&logger, /*is_0conf=*/false).unwrap();
9108                 let chan_3_value_msat = chan_3.context.channel_value_satoshis * 1000;
9109                 assert_eq!(chan_3.context.holder_max_htlc_value_in_flight_msat, (chan_3_value_msat as f64 * 0.02) as u64);
9110
9111                 // Test with the upper bound - 1 of valid values (99%).
9112                 let chan_4 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_99_percent), &channelmanager::provided_init_features(&config_99_percent), &chan_1_open_channel_msg, 7, &config_99_percent, 0, &&logger, /*is_0conf=*/false).unwrap();
9113                 let chan_4_value_msat = chan_4.context.channel_value_satoshis * 1000;
9114                 assert_eq!(chan_4.context.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);
9115
9116                 // Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
9117                 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
9118                 let chan_5 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42, None).unwrap();
9119                 let chan_5_value_msat = chan_5.context.channel_value_satoshis * 1000;
9120                 assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
9121
9122                 // Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values
9123                 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
9124                 // than 100.
9125                 let chan_6 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42, None).unwrap();
9126                 let chan_6_value_msat = chan_6.context.channel_value_satoshis * 1000;
9127                 assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
9128
9129                 // Test that `InboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
9130                 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
9131                 let chan_7 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_0_percent), &channelmanager::provided_init_features(&config_0_percent), &chan_1_open_channel_msg, 7, &config_0_percent, 0, &&logger, /*is_0conf=*/false).unwrap();
9132                 let chan_7_value_msat = chan_7.context.channel_value_satoshis * 1000;
9133                 assert_eq!(chan_7.context.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);
9134
9135                 // Test that `InboundV1Channel::new` uses the upper bound of the configurable percentage values
9136                 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
9137                 // than 100.
9138                 let chan_8 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_101_percent), &channelmanager::provided_init_features(&config_101_percent), &chan_1_open_channel_msg, 7, &config_101_percent, 0, &&logger, /*is_0conf=*/false).unwrap();
9139                 let chan_8_value_msat = chan_8.context.channel_value_satoshis * 1000;
9140                 assert_eq!(chan_8.context.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
9141         }
9142
9143         #[test]
9144         fn test_configured_holder_selected_channel_reserve_satoshis() {
9145
9146                 // Test that `OutboundV1Channel::new` and `InboundV1Channel::new` create a channel with the correct
9147                 // channel reserves, when `their_channel_reserve_proportional_millionths` is configured.
9148                 test_self_and_counterparty_channel_reserve(10_000_000, 0.02, 0.02);
9149
9150                 // Test with valid but unreasonably high channel reserves
9151                 // Requesting and accepting parties have requested for 49%-49% and 60%-30% channel reserve
9152                 test_self_and_counterparty_channel_reserve(10_000_000, 0.49, 0.49);
9153                 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.30);
9154
9155                 // Test with calculated channel reserve less than lower bound
9156                 // i.e `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
9157                 test_self_and_counterparty_channel_reserve(100_000, 0.00002, 0.30);
9158
9159                 // Test with invalid channel reserves since sum of both is greater than or equal
9160                 // to channel value
9161                 test_self_and_counterparty_channel_reserve(10_000_000, 0.50, 0.50);
9162                 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.50);
9163         }
9164
9165         fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
9166                 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 15_000 });
9167                 let logger = test_utils::TestLogger::new();
9168                 let secp_ctx = Secp256k1::new();
9169                 let seed = [42; 32];
9170                 let network = Network::Testnet;
9171                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
9172                 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9173                 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9174
9175
9176                 let mut outbound_node_config = UserConfig::default();
9177                 outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
9178                 let chan = OutboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&outbound_node_config), channel_value_satoshis, 100_000, 42, &outbound_node_config, 0, 42, None).unwrap();
9179
9180                 let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64);
9181                 assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
9182
9183                 let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network));
9184                 let mut inbound_node_config = UserConfig::default();
9185                 inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
9186
9187                 if outbound_selected_channel_reserve_perc + inbound_selected_channel_reserve_perc < 1.0 {
9188                         let chan_inbound_node = InboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, /*is_0conf=*/false).unwrap();
9189
9190                         let expected_inbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * inbound_selected_channel_reserve_perc) as u64);
9191
9192                         assert_eq!(chan_inbound_node.context.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
9193                         assert_eq!(chan_inbound_node.context.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
9194                 } else {
9195                         // Channel Negotiations failed
9196                         let result = InboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, /*is_0conf=*/false);
9197                         assert!(result.is_err());
9198                 }
9199         }
9200
9201         #[test]
9202         fn channel_update() {
9203                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
9204                 let logger = test_utils::TestLogger::new();
9205                 let secp_ctx = Secp256k1::new();
9206                 let seed = [42; 32];
9207                 let network = Network::Testnet;
9208                 let best_block = BestBlock::from_network(network);
9209                 let chain_hash = ChainHash::using_genesis_block(network);
9210                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
9211
9212                 // Create Node A's channel pointing to Node B's pubkey
9213                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9214                 let config = UserConfig::default();
9215                 let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
9216
9217                 // Create Node B's channel by receiving Node A's open_channel message
9218                 // Make sure A's dust limit is as we expect.
9219                 let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
9220                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
9221                 let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false).unwrap();
9222
9223                 // Node B --> Node A: accept channel, explicitly setting B's dust limit.
9224                 let mut accept_channel_msg = node_b_chan.accept_inbound_channel();
9225                 accept_channel_msg.dust_limit_satoshis = 546;
9226                 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
9227                 node_a_chan.context.holder_dust_limit_satoshis = 1560;
9228
9229                 // Node A --> Node B: funding created
9230                 let output_script = node_a_chan.context.get_funding_redeemscript();
9231                 let tx = Transaction { version: 1, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
9232                         value: 10000000, script_pubkey: output_script.clone(),
9233                 }]};
9234                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
9235                 let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
9236                 let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
9237
9238                 // Node B --> Node A: funding signed
9239                 let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
9240                 let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };
9241
9242                 // Make sure that receiving a channel update will update the Channel as expected.
9243                 let update = ChannelUpdate {
9244                         contents: UnsignedChannelUpdate {
9245                                 chain_hash,
9246                                 short_channel_id: 0,
9247                                 timestamp: 0,
9248                                 flags: 0,
9249                                 cltv_expiry_delta: 100,
9250                                 htlc_minimum_msat: 5,
9251                                 htlc_maximum_msat: MAX_VALUE_MSAT,
9252                                 fee_base_msat: 110,
9253                                 fee_proportional_millionths: 11,
9254                                 excess_data: Vec::new(),
9255                         },
9256                         signature: Signature::from(unsafe { FFISignature::new() })
9257                 };
9258                 assert!(node_a_chan.channel_update(&update).unwrap());
9259
9260                 // The counterparty can send an update with a higher minimum HTLC, but that shouldn't
9261                 // change our official htlc_minimum_msat.
9262                 assert_eq!(node_a_chan.context.holder_htlc_minimum_msat, 1);
9263                 match node_a_chan.context.counterparty_forwarding_info() {
9264                         Some(info) => {
9265                                 assert_eq!(info.cltv_expiry_delta, 100);
9266                                 assert_eq!(info.fee_base_msat, 110);
9267                                 assert_eq!(info.fee_proportional_millionths, 11);
9268                         },
9269                         None => panic!("expected counterparty forwarding info to be Some")
9270                 }
9271
9272                 assert!(!node_a_chan.channel_update(&update).unwrap());
9273         }
9274
9275         #[test]
9276         fn blinding_point_skimmed_fee_malformed_ser() {
9277                 // Ensure that channel blinding points, skimmed fees, and malformed HTLCs are (de)serialized
9278                 // properly.
9279                 let logger = test_utils::TestLogger::new();
9280                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
9281                 let secp_ctx = Secp256k1::new();
9282                 let seed = [42; 32];
9283                 let network = Network::Testnet;
9284                 let best_block = BestBlock::from_network(network);
9285                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
9286
9287                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9288                 let config = UserConfig::default();
9289                 let features = channelmanager::provided_init_features(&config);
9290                 let mut outbound_chan = OutboundV1Channel::<&TestKeysInterface>::new(
9291                         &feeest, &&keys_provider, &&keys_provider, node_b_node_id, &features, 10000000, 100000, 42, &config, 0, 42, None
9292                 ).unwrap();
9293                 let inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
9294                         &feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config),
9295                         &features, &outbound_chan.get_open_channel(ChainHash::using_genesis_block(network)), 7, &config, 0, &&logger, false
9296                 ).unwrap();
9297                 outbound_chan.accept_channel(&inbound_chan.get_accept_channel_message(), &config.channel_handshake_limits, &features).unwrap();
9298                 let tx = Transaction { version: 1, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
9299                         value: 10000000, script_pubkey: outbound_chan.context.get_funding_redeemscript(),
9300                 }]};
9301                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
9302                 let funding_created = outbound_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap().unwrap();
9303                 let mut chan = match inbound_chan.funding_created(&funding_created, best_block, &&keys_provider, &&logger) {
9304                         Ok((chan, _, _)) => chan,
9305                         Err((_, e)) => panic!("{}", e),
9306                 };
9307
9308                 let dummy_htlc_source = HTLCSource::OutboundRoute {
9309                         path: Path {
9310                                 hops: vec![RouteHop {
9311                                         pubkey: test_utils::pubkey(2), channel_features: ChannelFeatures::empty(),
9312                                         node_features: NodeFeatures::empty(), short_channel_id: 0, fee_msat: 0,
9313                                         cltv_expiry_delta: 0, maybe_announced_channel: false,
9314                                 }],
9315                                 blinded_tail: None
9316                         },
9317                         session_priv: test_utils::privkey(42),
9318                         first_hop_htlc_msat: 0,
9319                         payment_id: PaymentId([42; 32]),
9320                 };
9321                 let dummy_outbound_output = OutboundHTLCOutput {
9322                         htlc_id: 0,
9323                         amount_msat: 0,
9324                         payment_hash: PaymentHash([43; 32]),
9325                         cltv_expiry: 0,
9326                         state: OutboundHTLCState::Committed,
9327                         source: dummy_htlc_source.clone(),
9328                         skimmed_fee_msat: None,
9329                         blinding_point: None,
9330                 };
9331                 let mut pending_outbound_htlcs = vec![dummy_outbound_output.clone(); 10];
9332                 for (idx, htlc) in pending_outbound_htlcs.iter_mut().enumerate() {
9333                         if idx % 2 == 0 {
9334                                 htlc.blinding_point = Some(test_utils::pubkey(42 + idx as u8));
9335                         }
9336                         if idx % 3 == 0 {
9337                                 htlc.skimmed_fee_msat = Some(1);
9338                         }
9339                 }
9340                 chan.context.pending_outbound_htlcs = pending_outbound_htlcs.clone();
9341
9342                 let dummy_holding_cell_add_htlc = HTLCUpdateAwaitingACK::AddHTLC {
9343                         amount_msat: 0,
9344                         cltv_expiry: 0,
9345                         payment_hash: PaymentHash([43; 32]),
9346                         source: dummy_htlc_source.clone(),
9347                         onion_routing_packet: msgs::OnionPacket {
9348                                 version: 0,
9349                                 public_key: Ok(test_utils::pubkey(1)),
9350                                 hop_data: [0; 20*65],
9351                                 hmac: [0; 32]
9352                         },
9353                         skimmed_fee_msat: None,
9354                         blinding_point: None,
9355                 };
9356                 let dummy_holding_cell_claim_htlc = HTLCUpdateAwaitingACK::ClaimHTLC {
9357                         payment_preimage: PaymentPreimage([42; 32]),
9358                         htlc_id: 0,
9359                 };
9360                 let dummy_holding_cell_failed_htlc = |htlc_id| HTLCUpdateAwaitingACK::FailHTLC {
9361                         htlc_id, err_packet: msgs::OnionErrorPacket { data: vec![42] }
9362                 };
9363                 let dummy_holding_cell_malformed_htlc = |htlc_id| HTLCUpdateAwaitingACK::FailMalformedHTLC {
9364                         htlc_id, failure_code: INVALID_ONION_BLINDING, sha256_of_onion: [0; 32],
9365                 };
9366                 let mut holding_cell_htlc_updates = Vec::with_capacity(12);
9367                 for i in 0..12 {
9368                         if i % 5 == 0 {
9369                                 holding_cell_htlc_updates.push(dummy_holding_cell_add_htlc.clone());
9370                         } else if i % 5 == 1 {
9371                                 holding_cell_htlc_updates.push(dummy_holding_cell_claim_htlc.clone());
9372                         } else if i % 5 == 2 {
9373                                 let mut dummy_add = dummy_holding_cell_add_htlc.clone();
9374                                 if let HTLCUpdateAwaitingACK::AddHTLC {
9375                                         ref mut blinding_point, ref mut skimmed_fee_msat, ..
9376                                 } = &mut dummy_add {
9377                                         *blinding_point = Some(test_utils::pubkey(42 + i));
9378                                         *skimmed_fee_msat = Some(42);
9379                                 } else { panic!() }
9380                                 holding_cell_htlc_updates.push(dummy_add);
9381                         } else if i % 5 == 3 {
9382                                 holding_cell_htlc_updates.push(dummy_holding_cell_malformed_htlc(i as u64));
9383                         } else {
9384                                 holding_cell_htlc_updates.push(dummy_holding_cell_failed_htlc(i as u64));
9385                         }
9386                 }
9387                 chan.context.holding_cell_htlc_updates = holding_cell_htlc_updates.clone();
9388
9389                 // Encode and decode the channel and ensure that the HTLCs within are the same.
9390                 let encoded_chan = chan.encode();
9391                 let mut s = crate::io::Cursor::new(&encoded_chan);
9392                 let mut reader = crate::util::ser::FixedLengthReader::new(&mut s, encoded_chan.len() as u64);
9393                 let features = channelmanager::provided_channel_type_features(&config);
9394                 let decoded_chan = Channel::read(&mut reader, (&&keys_provider, &&keys_provider, 0, &features)).unwrap();
9395                 assert_eq!(decoded_chan.context.pending_outbound_htlcs, pending_outbound_htlcs);
9396                 assert_eq!(decoded_chan.context.holding_cell_htlc_updates, holding_cell_htlc_updates);
9397         }
9398
9399         #[cfg(all(feature = "_test_vectors", not(feature = "grind_signatures")))]
9400         #[test]
9401         fn outbound_commitment_test() {
9402                 use bitcoin::sighash;
9403                 use bitcoin::consensus::encode::serialize;
9404                 use bitcoin::sighash::EcdsaSighashType;
9405                 use bitcoin::hashes::hex::FromHex;
9406                 use bitcoin::hash_types::Txid;
9407                 use bitcoin::secp256k1::Message;
9408                 use crate::sign::{ChannelDerivationParameters, HTLCDescriptor, ecdsa::EcdsaChannelSigner};
9409                 use crate::ln::PaymentPreimage;
9410                 use crate::ln::channel::{HTLCOutputInCommitment ,TxCreationKeys};
9411                 use crate::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint};
9412                 use crate::ln::chan_utils::{ChannelPublicKeys, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters};
9413                 use crate::util::logger::Logger;
9414                 use crate::sync::Arc;
9415                 use core::str::FromStr;
9416                 use hex::DisplayHex;
9417
9418                 // Test vectors from BOLT 3 Appendices C and F (anchors):
9419                 let feeest = TestFeeEstimator{fee_est: 15000};
9420                 let logger : Arc<dyn Logger> = Arc::new(test_utils::TestLogger::new());
9421                 let secp_ctx = Secp256k1::new();
9422
9423                 let mut signer = InMemorySigner::new(
9424                         &secp_ctx,
9425                         SecretKey::from_slice(&<Vec<u8>>::from_hex("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749").unwrap()[..]).unwrap(),
9426                         SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
9427                         SecretKey::from_slice(&<Vec<u8>>::from_hex("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
9428                         SecretKey::from_slice(&<Vec<u8>>::from_hex("3333333333333333333333333333333333333333333333333333333333333333").unwrap()[..]).unwrap(),
9429                         SecretKey::from_slice(&<Vec<u8>>::from_hex("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
9430
9431                         // These aren't set in the test vectors:
9432                         [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
9433                         10_000_000,
9434                         [0; 32],
9435                         [0; 32],
9436                 );
9437
9438                 assert_eq!(signer.pubkeys().funding_pubkey.serialize()[..],
9439                                 <Vec<u8>>::from_hex("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
9440                 let keys_provider = Keys { signer: signer.clone() };
9441
9442                 let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
9443                 let mut config = UserConfig::default();
9444                 config.channel_handshake_config.announced_channel = false;
9445                 let mut chan = OutboundV1Channel::<&Keys>::new(&LowerBoundedFeeEstimator::new(&feeest), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42, None).unwrap(); // Nothing uses their network key in this test
9446                 chan.context.holder_dust_limit_satoshis = 546;
9447                 chan.context.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
9448
9449                 let funding_info = OutPoint{ txid: Txid::from_str("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), index: 0 };
9450
9451                 let counterparty_pubkeys = ChannelPublicKeys {
9452                         funding_pubkey: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
9453                         revocation_basepoint: RevocationBasepoint::from(PublicKey::from_slice(&<Vec<u8>>::from_hex("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap()),
9454                         payment_point: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"),
9455                         delayed_payment_basepoint: DelayedPaymentBasepoint::from(public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13")),
9456                         htlc_basepoint: HtlcBasepoint::from(public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"))
9457                 };
9458                 chan.context.channel_transaction_parameters.counterparty_parameters = Some(
9459                         CounterpartyChannelTransactionParameters {
9460                                 pubkeys: counterparty_pubkeys.clone(),
9461                                 selected_contest_delay: 144
9462                         });
9463                 chan.context.channel_transaction_parameters.funding_outpoint = Some(funding_info);
9464                 signer.provide_channel_parameters(&chan.context.channel_transaction_parameters);
9465
9466                 assert_eq!(counterparty_pubkeys.payment_point.serialize()[..],
9467                            <Vec<u8>>::from_hex("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
9468
9469                 assert_eq!(counterparty_pubkeys.funding_pubkey.serialize()[..],
9470                            <Vec<u8>>::from_hex("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1").unwrap()[..]);
9471
9472                 assert_eq!(counterparty_pubkeys.htlc_basepoint.to_public_key().serialize()[..],
9473                            <Vec<u8>>::from_hex("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
9474
9475                 // We can't just use build_holder_transaction_keys here as the per_commitment_secret is not
9476                 // derived from a commitment_seed, so instead we copy it here and call
9477                 // build_commitment_transaction.
9478                 let delayed_payment_base = &chan.context.holder_signer.as_ref().pubkeys().delayed_payment_basepoint;
9479                 let per_commitment_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
9480                 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
9481                 let htlc_basepoint = &chan.context.holder_signer.as_ref().pubkeys().htlc_basepoint;
9482                 let keys = TxCreationKeys::derive_new(&secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint);
9483
9484                 macro_rules! test_commitment {
9485                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
9486                                 chan.context.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::only_static_remote_key();
9487                                 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::only_static_remote_key(), $($remain)*);
9488                         };
9489                 }
9490
9491                 macro_rules! test_commitment_with_anchors {
9492                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
9493                                 chan.context.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
9494                                 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(), $($remain)*);
9495                         };
9496                 }
9497
9498                 macro_rules! test_commitment_common {
9499                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $opt_anchors: expr, {
9500                                 $( { $htlc_idx: expr, $counterparty_htlc_sig_hex: expr, $htlc_sig_hex: expr, $htlc_tx_hex: expr } ), *
9501                         } ) => { {
9502                                 let (commitment_tx, htlcs): (_, Vec<HTLCOutputInCommitment>) = {
9503                                         let mut commitment_stats = chan.context.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false, &logger);
9504
9505                                         let htlcs = commitment_stats.htlcs_included.drain(..)
9506                                                 .filter_map(|(htlc, _)| if htlc.transaction_output_index.is_some() { Some(htlc) } else { None })
9507                                                 .collect();
9508                                         (commitment_stats.tx, htlcs)
9509                                 };
9510                                 let trusted_tx = commitment_tx.trust();
9511                                 let unsigned_tx = trusted_tx.built_transaction();
9512                                 let redeemscript = chan.context.get_funding_redeemscript();
9513                                 let counterparty_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_sig_hex).unwrap()[..]).unwrap();
9514                                 let sighash = unsigned_tx.get_sighash_all(&redeemscript, chan.context.channel_value_satoshis);
9515                                 log_trace!(logger, "unsigned_tx = {}", serialize(&unsigned_tx.transaction).as_hex());
9516                                 assert!(secp_ctx.verify_ecdsa(&sighash, &counterparty_signature, chan.context.counterparty_funding_pubkey()).is_ok(), "verify counterparty commitment sig");
9517
9518                                 let mut per_htlc: Vec<(HTLCOutputInCommitment, Option<Signature>)> = Vec::new();
9519                                 per_htlc.clear(); // Don't warn about excess mut for no-HTLC calls
9520                                 let mut counterparty_htlc_sigs = Vec::new();
9521                                 counterparty_htlc_sigs.clear(); // Don't warn about excess mut for no-HTLC calls
9522                                 $({
9523                                         let remote_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
9524                                         per_htlc.push((htlcs[$htlc_idx].clone(), Some(remote_signature)));
9525                                         counterparty_htlc_sigs.push(remote_signature);
9526                                 })*
9527                                 assert_eq!(htlcs.len(), per_htlc.len());
9528
9529                                 let holder_commitment_tx = HolderCommitmentTransaction::new(
9530                                         commitment_tx.clone(),
9531                                         counterparty_signature,
9532                                         counterparty_htlc_sigs,
9533                                         &chan.context.holder_signer.as_ref().pubkeys().funding_pubkey,
9534                                         chan.context.counterparty_funding_pubkey()
9535                                 );
9536                                 let holder_sig = signer.sign_holder_commitment(&holder_commitment_tx, &secp_ctx).unwrap();
9537                                 assert_eq!(Signature::from_der(&<Vec<u8>>::from_hex($sig_hex).unwrap()[..]).unwrap(), holder_sig, "holder_sig");
9538
9539                                 let funding_redeemscript = chan.context.get_funding_redeemscript();
9540                                 let tx = holder_commitment_tx.add_holder_sig(&funding_redeemscript, holder_sig);
9541                                 assert_eq!(serialize(&tx)[..], <Vec<u8>>::from_hex($tx_hex).unwrap()[..], "tx");
9542
9543                                 // ((htlc, counterparty_sig), (index, holder_sig))
9544                                 let mut htlc_counterparty_sig_iter = holder_commitment_tx.counterparty_htlc_sigs.iter();
9545
9546                                 $({
9547                                         log_trace!(logger, "verifying htlc {}", $htlc_idx);
9548                                         let remote_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
9549
9550                                         let ref htlc = htlcs[$htlc_idx];
9551                                         let mut htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, chan.context.feerate_per_kw,
9552                                                 chan.context.get_counterparty_selected_contest_delay().unwrap(),
9553                                                 &htlc, $opt_anchors, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
9554                                         let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, $opt_anchors, &keys);
9555                                         let htlc_sighashtype = if $opt_anchors.supports_anchors_zero_fee_htlc_tx() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
9556                                         let htlc_sighash = Message::from_slice(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]).unwrap();
9557                                         assert!(secp_ctx.verify_ecdsa(&htlc_sighash, &remote_signature, &keys.countersignatory_htlc_key.to_public_key()).is_ok(), "verify counterparty htlc sig");
9558
9559                                         let mut preimage: Option<PaymentPreimage> = None;
9560                                         if !htlc.offered {
9561                                                 for i in 0..5 {
9562                                                         let out = PaymentHash(Sha256::hash(&[i; 32]).to_byte_array());
9563                                                         if out == htlc.payment_hash {
9564                                                                 preimage = Some(PaymentPreimage([i; 32]));
9565                                                         }
9566                                                 }
9567
9568                                                 assert!(preimage.is_some());
9569                                         }
9570
9571                                         let htlc_counterparty_sig = htlc_counterparty_sig_iter.next().unwrap();
9572                                         let htlc_holder_sig = signer.sign_holder_htlc_transaction(&htlc_tx, 0, &HTLCDescriptor {
9573                                                 channel_derivation_parameters: ChannelDerivationParameters {
9574                                                         value_satoshis: chan.context.channel_value_satoshis,
9575                                                         keys_id: chan.context.channel_keys_id,
9576                                                         transaction_parameters: chan.context.channel_transaction_parameters.clone(),
9577                                                 },
9578                                                 commitment_txid: trusted_tx.txid(),
9579                                                 per_commitment_number: trusted_tx.commitment_number(),
9580                                                 per_commitment_point: trusted_tx.per_commitment_point(),
9581                                                 feerate_per_kw: trusted_tx.feerate_per_kw(),
9582                                                 htlc: htlc.clone(),
9583                                                 preimage: preimage.clone(),
9584                                                 counterparty_sig: *htlc_counterparty_sig,
9585                                         }, &secp_ctx).unwrap();
9586                                         let num_anchors = if $opt_anchors.supports_anchors_zero_fee_htlc_tx() { 2 } else { 0 };
9587                                         assert_eq!(htlc.transaction_output_index, Some($htlc_idx + num_anchors), "output index");
9588
9589                                         let signature = Signature::from_der(&<Vec<u8>>::from_hex($htlc_sig_hex).unwrap()[..]).unwrap();
9590                                         assert_eq!(signature, htlc_holder_sig, "htlc sig");
9591                                         let trusted_tx = holder_commitment_tx.trust();
9592                                         htlc_tx.input[0].witness = trusted_tx.build_htlc_input_witness($htlc_idx, htlc_counterparty_sig, &htlc_holder_sig, &preimage);
9593                                         log_trace!(logger, "htlc_tx = {}", serialize(&htlc_tx).as_hex());
9594                                         assert_eq!(serialize(&htlc_tx)[..], <Vec<u8>>::from_hex($htlc_tx_hex).unwrap()[..], "htlc tx");
9595                                 })*
9596                                 assert!(htlc_counterparty_sig_iter.next().is_none());
9597                         } }
9598                 }
9599
9600                 // anchors: simple commitment tx with no HTLCs and single anchor
9601                 test_commitment_with_anchors!("30440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a8658",
9602                                                  "3044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778",
9603                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
9604
9605                 // simple commitment tx with no HTLCs
9606                 chan.context.value_to_self_msat = 7000000000;
9607
9608                 test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
9609                                                  "30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
9610                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48454a56a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004730440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae05564714201483045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
9611
9612                 // anchors: simple commitment tx with no HTLCs
9613                 test_commitment_with_anchors!("3045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f3",
9614                                                  "30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
9615                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
9616
9617                 chan.context.pending_inbound_htlcs.push({
9618                         let mut out = InboundHTLCOutput{
9619                                 htlc_id: 0,
9620                                 amount_msat: 1000000,
9621                                 cltv_expiry: 500,
9622                                 payment_hash: PaymentHash([0; 32]),
9623                                 state: InboundHTLCState::Committed,
9624                         };
9625                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0000000000000000000000000000000000000000000000000000000000000000").unwrap()).to_byte_array();
9626                         out
9627                 });
9628                 chan.context.pending_inbound_htlcs.push({
9629                         let mut out = InboundHTLCOutput{
9630                                 htlc_id: 1,
9631                                 amount_msat: 2000000,
9632                                 cltv_expiry: 501,
9633                                 payment_hash: PaymentHash([0; 32]),
9634                                 state: InboundHTLCState::Committed,
9635                         };
9636                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).to_byte_array();
9637                         out
9638                 });
9639                 chan.context.pending_outbound_htlcs.push({
9640                         let mut out = OutboundHTLCOutput{
9641                                 htlc_id: 2,
9642                                 amount_msat: 2000000,
9643                                 cltv_expiry: 502,
9644                                 payment_hash: PaymentHash([0; 32]),
9645                                 state: OutboundHTLCState::Committed,
9646                                 source: HTLCSource::dummy(),
9647                                 skimmed_fee_msat: None,
9648                                 blinding_point: None,
9649                         };
9650                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0202020202020202020202020202020202020202020202020202020202020202").unwrap()).to_byte_array();
9651                         out
9652                 });
9653                 chan.context.pending_outbound_htlcs.push({
9654                         let mut out = OutboundHTLCOutput{
9655                                 htlc_id: 3,
9656                                 amount_msat: 3000000,
9657                                 cltv_expiry: 503,
9658                                 payment_hash: PaymentHash([0; 32]),
9659                                 state: OutboundHTLCState::Committed,
9660                                 source: HTLCSource::dummy(),
9661                                 skimmed_fee_msat: None,
9662                                 blinding_point: None,
9663                         };
9664                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0303030303030303030303030303030303030303030303030303030303030303").unwrap()).to_byte_array();
9665                         out
9666                 });
9667                 chan.context.pending_inbound_htlcs.push({
9668                         let mut out = InboundHTLCOutput{
9669                                 htlc_id: 4,
9670                                 amount_msat: 4000000,
9671                                 cltv_expiry: 504,
9672                                 payment_hash: PaymentHash([0; 32]),
9673                                 state: InboundHTLCState::Committed,
9674                         };
9675                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0404040404040404040404040404040404040404040404040404040404040404").unwrap()).to_byte_array();
9676                         out
9677                 });
9678
9679                 // commitment tx with all five HTLCs untrimmed (minimum feerate)
9680                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9681                 chan.context.feerate_per_kw = 0;
9682
9683                 test_commitment!("3044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e5",
9684                                  "304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea",
9685                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e0a06a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea01473044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9686
9687                                   { 0,
9688                                   "3045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b",
9689                                   "30440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce",
9690                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b00000000000000000001e8030000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b014730440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
9691
9692                                   { 1,
9693                                   "30440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f896004",
9694                                   "3045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f",
9695                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b01000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f89600401483045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9696
9697                                   { 2,
9698                                   "30440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d43352",
9699                                   "3045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa",
9700                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b02000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d4335201483045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
9701
9702                                   { 3,
9703                                   "304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c1363",
9704                                   "304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac7487",
9705                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b03000000000000000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c13630147304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac748701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9706
9707                                   { 4,
9708                                   "3044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b87",
9709                                   "3045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95",
9710                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b04000000000000000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b8701483045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9711                 } );
9712
9713                 // commitment tx with seven outputs untrimmed (maximum feerate)
9714                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9715                 chan.context.feerate_per_kw = 647;
9716
9717                 test_commitment!("3045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee",
9718                                  "30450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb7",
9719                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e09c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb701483045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9720
9721                                   { 0,
9722                                   "30450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f",
9723                                   "30440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b",
9724                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f014730440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
9725
9726                                   { 1,
9727                                   "304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c",
9728                                   "30450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f",
9729                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0100000000000000000124060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c014830450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9730
9731                                   { 2,
9732                                   "30440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c8",
9733                                   "3045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673",
9734                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe020000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c801483045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
9735
9736                                   { 3,
9737                                   "304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c64",
9738                                   "3045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee",
9739                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe030000000000000000010c0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c6401483045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9740
9741                                   { 4,
9742                                   "30450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca",
9743                                   "3044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9",
9744                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe04000000000000000001da0d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca01473044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9745                 } );
9746
9747                 // commitment tx with six outputs untrimmed (minimum feerate)
9748                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9749                 chan.context.feerate_per_kw = 648;
9750
9751                 test_commitment!("304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e5",
9752                                  "3045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e9",
9753                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4844e9d6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e90147304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9754
9755                                   { 0,
9756                                   "3045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e0",
9757                                   "304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec6",
9758                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10000000000000000000123060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e00148304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9759
9760                                   { 1,
9761                                   "304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d384124",
9762                                   "3044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae",
9763                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10100000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d38412401473044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
9764
9765                                   { 2,
9766                                   "304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc625532989",
9767                                   "3045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e2260796",
9768                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf1020000000000000000010b0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc62553298901483045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e226079601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9769
9770                                   { 3,
9771                                   "3044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be",
9772                                   "3045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6",
9773                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf103000000000000000001d90d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be01483045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9774                 } );
9775
9776                 // anchors: commitment tx with six outputs untrimmed (minimum dust limit)
9777                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9778                 chan.context.feerate_per_kw = 645;
9779                 chan.context.holder_dust_limit_satoshis = 1001;
9780
9781                 test_commitment_with_anchors!("3044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc312",
9782                                  "3045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d0051",
9783                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80084a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d0070000000000002200203e68115ae0b15b8de75b6c6bc9af5ac9f01391544e0870dae443a1e8fe7837ead007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5eb80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994abc996a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d005101473044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc31201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9784
9785                                   { 0,
9786                                   "3045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc282",
9787                                   "3045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef09",
9788                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320002000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc28283483045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef0901008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6851b27568f6010000" },
9789
9790                                   { 1,
9791                                   "3045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e",
9792                                   "3045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac",
9793                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320003000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e83483045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
9794
9795                                   { 2,
9796                                   "3044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c1",
9797                                   "304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e",
9798                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320004000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c18347304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
9799
9800                                   { 3,
9801                                   "3044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc615",
9802                                   "3045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226",
9803                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320005000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc61583483045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
9804                 } );
9805
9806                 // commitment tx with six outputs untrimmed (maximum feerate)
9807                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9808                 chan.context.feerate_per_kw = 2069;
9809                 chan.context.holder_dust_limit_satoshis = 546;
9810
9811                 test_commitment!("304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc",
9812                                  "3045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e33",
9813                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48477956a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e330148304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9814
9815                                   { 0,
9816                                   "3045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f699",
9817                                   "3045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d",
9818                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0000000000000000000175020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f69901483045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9819
9820                                   { 1,
9821                                   "3045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df",
9822                                   "3045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61",
9823                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0100000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df01483045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
9824
9825                                   { 2,
9826                                   "3045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e0",
9827                                   "3044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c18",
9828                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d020000000000000000015d060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e001473044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c1801008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9829
9830                                   { 3,
9831                                   "304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df",
9832                                   "3045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33",
9833                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d03000000000000000001f2090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df01483045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9834                 } );
9835
9836                 // commitment tx with five outputs untrimmed (minimum feerate)
9837                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9838                 chan.context.feerate_per_kw = 2070;
9839
9840                 test_commitment!("304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c",
9841                                  "3044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c1",
9842                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484da966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c10147304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9843
9844                                   { 0,
9845                                   "304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b",
9846                                   "30440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e5",
9847                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff0000000000000000000174020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b014730440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e501008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9848
9849                                   { 1,
9850                                   "3045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546",
9851                                   "30450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c6",
9852                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff010000000000000000015c060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546014830450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9853
9854                                   { 2,
9855                                   "3045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504",
9856                                   "30440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502",
9857                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff02000000000000000001f1090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504014730440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9858                 } );
9859
9860                 // commitment tx with five outputs untrimmed (maximum feerate)
9861                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9862                 chan.context.feerate_per_kw = 2194;
9863
9864                 test_commitment!("304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb3",
9865                                  "3044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d398",
9866                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48440966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d3980147304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9867
9868                                   { 0,
9869                                   "3045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de8450",
9870                                   "304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e0154301",
9871                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de84500148304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e015430101008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
9872
9873                                   { 1,
9874                                   "3044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a0",
9875                                   "3045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b77",
9876                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd010000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a001483045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b7701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9877
9878                                   { 2,
9879                                   "3045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b",
9880                                   "30450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3",
9881                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd020000000000000000019a090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b014830450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9882                 } );
9883
9884                 // commitment tx with four outputs untrimmed (minimum feerate)
9885                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9886                 chan.context.feerate_per_kw = 2195;
9887
9888                 test_commitment!("304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce403",
9889                                  "3044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d1767",
9890                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484b8976a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d17670147304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce40301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9891
9892                                   { 0,
9893                                   "3045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e",
9894                                   "3045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d76",
9895                                   "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900000000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e01483045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d7601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9896
9897                                   { 1,
9898                                   "3045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a",
9899                                   "3044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82",
9900                                   "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900100000000000000000199090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a01473044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9901                 } );
9902
9903                 // anchors: commitment tx with four outputs untrimmed (minimum dust limit)
9904                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9905                 chan.context.feerate_per_kw = 2185;
9906                 chan.context.holder_dust_limit_satoshis = 2001;
9907                 let cached_channel_type = chan.context.channel_type;
9908                 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
9909
9910                 test_commitment_with_anchors!("3044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c0",
9911                                  "3045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd5",
9912                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80064a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994b80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ac5916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd501473044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9913
9914                                   { 0,
9915                                   "304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb",
9916                                   "30440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f",
9917                                   "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc02000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb834730440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
9918
9919                                   { 1,
9920                                   "3045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd7271",
9921                                   "3045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688",
9922                                   "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc03000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd727183483045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
9923                 } );
9924
9925                 // commitment tx with four outputs untrimmed (maximum feerate)
9926                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9927                 chan.context.feerate_per_kw = 3702;
9928                 chan.context.holder_dust_limit_satoshis = 546;
9929                 chan.context.channel_type = cached_channel_type.clone();
9930
9931                 test_commitment!("304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee40169",
9932                                  "3045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf75",
9933                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4846f916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf750148304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee4016901475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9934
9935                                   { 0,
9936                                   "304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb89",
9937                                   "304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f",
9938                                   "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb890147304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
9939
9940                                   { 1,
9941                                   "3044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb5817",
9942                                   "304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc",
9943                                   "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0100000000000000000176050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb58170147304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9944                 } );
9945
9946                 // commitment tx with three outputs untrimmed (minimum feerate)
9947                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9948                 chan.context.feerate_per_kw = 3703;
9949
9950                 test_commitment!("3045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e",
9951                                  "304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e1",
9952                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484eb936a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e101483045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9953
9954                                   { 0,
9955                                   "3045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a",
9956                                   "3045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05",
9957                                   "0200000000010120060e4a29579d429f0f27c17ee5f1ee282f20d706d6f90b63d35946d8f3029a0000000000000000000175050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a01483045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9958                 } );
9959
9960                 // anchors: commitment tx with three outputs untrimmed (minimum dust limit)
9961                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9962                 chan.context.feerate_per_kw = 3687;
9963                 chan.context.holder_dust_limit_satoshis = 3001;
9964                 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
9965
9966                 test_commitment_with_anchors!("3045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c228377",
9967                                  "3045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d",
9968                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80054a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aa28b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d01483045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c22837701475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9969
9970                                   { 0,
9971                                   "3044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c",
9972                                   "3045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de",
9973                                   "02000000000101542562b326c08e3a076d9cfca2be175041366591da334d8d513ff1686fd95a6002000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c83483045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
9974                 } );
9975
9976                 // commitment tx with three outputs untrimmed (maximum feerate)
9977                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9978                 chan.context.feerate_per_kw = 4914;
9979                 chan.context.holder_dust_limit_satoshis = 546;
9980                 chan.context.channel_type = cached_channel_type.clone();
9981
9982                 test_commitment!("3045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c95244",
9983                                  "3045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c19",
9984                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484ae8f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c1901483045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c9524401475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
9985
9986                                   { 0,
9987                                   "3045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374",
9988                                   "30440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10",
9989                                   "02000000000101a9172908eace869cc35128c31fc2ab502f72e4dff31aab23e0244c4b04b11ab00000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374014730440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
9990                 } );
9991
9992                 // commitment tx with two outputs untrimmed (minimum feerate)
9993                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
9994                 chan.context.feerate_per_kw = 4915;
9995                 chan.context.holder_dust_limit_satoshis = 546;
9996
9997                 test_commitment!("304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a720",
9998                                  "30450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf5",
9999                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484fa926a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf50147304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a72001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10000
10001                 // anchors: commitment tx with two outputs untrimmed (minimum dust limit)
10002                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
10003                 chan.context.feerate_per_kw = 4894;
10004                 chan.context.holder_dust_limit_satoshis = 4001;
10005                 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
10006
10007                 test_commitment_with_anchors!("3045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b95",
10008                                  "30450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd",
10009                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ad0886a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd01483045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b9501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10010
10011                 // commitment tx with two outputs untrimmed (maximum feerate)
10012                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
10013                 chan.context.feerate_per_kw = 9651180;
10014                 chan.context.holder_dust_limit_satoshis = 546;
10015                 chan.context.channel_type = cached_channel_type.clone();
10016
10017                 test_commitment!("304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd3",
10018                                  "3045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de",
10019                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b800222020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80ec0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4840400483045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de0147304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10020
10021                 // commitment tx with one output untrimmed (minimum feerate)
10022                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
10023                 chan.context.feerate_per_kw = 9651181;
10024
10025                 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
10026                                  "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
10027                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10028
10029                 // anchors: commitment tx with one output untrimmed (minimum dust limit)
10030                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
10031                 chan.context.feerate_per_kw = 6216010;
10032                 chan.context.holder_dust_limit_satoshis = 4001;
10033                 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
10034
10035                 test_commitment_with_anchors!("30450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf",
10036                                  "30450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1",
10037                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a04004830450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1014830450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10038
10039                 // commitment tx with fee greater than funder amount
10040                 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
10041                 chan.context.feerate_per_kw = 9651936;
10042                 chan.context.holder_dust_limit_satoshis = 546;
10043                 chan.context.channel_type = cached_channel_type;
10044
10045                 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
10046                                  "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
10047                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
10048
10049                 // commitment tx with 3 htlc outputs, 2 offered having the same amount and preimage
10050                 chan.context.value_to_self_msat = 7_000_000_000 - 2_000_000;
10051                 chan.context.feerate_per_kw = 253;
10052                 chan.context.pending_inbound_htlcs.clear();
10053                 chan.context.pending_inbound_htlcs.push({
10054                         let mut out = InboundHTLCOutput{
10055                                 htlc_id: 1,
10056                                 amount_msat: 2000000,
10057                                 cltv_expiry: 501,
10058                                 payment_hash: PaymentHash([0; 32]),
10059                                 state: InboundHTLCState::Committed,
10060                         };
10061                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).to_byte_array();
10062                         out
10063                 });
10064                 chan.context.pending_outbound_htlcs.clear();
10065                 chan.context.pending_outbound_htlcs.push({
10066                         let mut out = OutboundHTLCOutput{
10067                                 htlc_id: 6,
10068                                 amount_msat: 5000001,
10069                                 cltv_expiry: 506,
10070                                 payment_hash: PaymentHash([0; 32]),
10071                                 state: OutboundHTLCState::Committed,
10072                                 source: HTLCSource::dummy(),
10073                                 skimmed_fee_msat: None,
10074                                 blinding_point: None,
10075                         };
10076                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).to_byte_array();
10077                         out
10078                 });
10079                 chan.context.pending_outbound_htlcs.push({
10080                         let mut out = OutboundHTLCOutput{
10081                                 htlc_id: 5,
10082                                 amount_msat: 5000000,
10083                                 cltv_expiry: 505,
10084                                 payment_hash: PaymentHash([0; 32]),
10085                                 state: OutboundHTLCState::Committed,
10086                                 source: HTLCSource::dummy(),
10087                                 skimmed_fee_msat: None,
10088                                 blinding_point: None,
10089                         };
10090                         out.payment_hash.0 = Sha256::hash(&<Vec<u8>>::from_hex("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).to_byte_array();
10091                         out
10092                 });
10093
10094                 test_commitment!("304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c8",
10095                                  "304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c",
10096                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2d8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121b8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121bc0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484a69f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c0147304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
10097
10098                                   { 0,
10099                                   "3045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce5",
10100                                   "3044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b",
10101                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec000000000000000000011f070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce501473044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
10102                                   { 1,
10103                                   "3045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a",
10104                                   "3045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d",
10105                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec01000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a01483045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868f9010000" },
10106                                   { 2,
10107                                   "30440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc",
10108                                   "304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb",
10109                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec02000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc0147304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868fa010000" }
10110                 } );
10111
10112                 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
10113                 test_commitment_with_anchors!("3044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c725",
10114                                  "3045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b76",
10115                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80074a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5e881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aad9c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b7601473044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c72501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
10116
10117                                   { 0,
10118                                   "30440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c2",
10119                                   "304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424",
10120                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c402000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c28347304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
10121                                   { 1,
10122                                   "304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c",
10123                                   "304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b",
10124                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40300000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c8347304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568f9010000" },
10125                                   { 2,
10126                                   "3045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a1",
10127                                   "3045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b",
10128                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40400000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a183483045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568fa010000" }
10129                 } );
10130         }
10131
10132         #[test]
10133         fn test_per_commitment_secret_gen() {
10134                 // Test vectors from BOLT 3 Appendix D:
10135
10136                 let mut seed = [0; 32];
10137                 seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
10138                 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
10139                            <Vec<u8>>::from_hex("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]);
10140
10141                 seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap());
10142                 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
10143                            <Vec<u8>>::from_hex("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]);
10144
10145                 assert_eq!(chan_utils::build_commitment_secret(&seed, 0xaaaaaaaaaaa),
10146                            <Vec<u8>>::from_hex("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]);
10147
10148                 assert_eq!(chan_utils::build_commitment_secret(&seed, 0x555555555555),
10149                            <Vec<u8>>::from_hex("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]);
10150
10151                 seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap());
10152                 assert_eq!(chan_utils::build_commitment_secret(&seed, 1),
10153                            <Vec<u8>>::from_hex("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]);
10154         }
10155
10156         #[test]
10157         fn test_key_derivation() {
10158                 // Test vectors from BOLT 3 Appendix E:
10159                 let secp_ctx = Secp256k1::new();
10160
10161                 let base_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap();
10162                 let per_commitment_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
10163
10164                 let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret);
10165                 assert_eq!(base_point.serialize()[..], <Vec<u8>>::from_hex("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]);
10166
10167                 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
10168                 assert_eq!(per_commitment_point.serialize()[..], <Vec<u8>>::from_hex("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]);
10169
10170                 assert_eq!(chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &base_secret),
10171                                 SecretKey::from_slice(&<Vec<u8>>::from_hex("cbced912d3b21bf196a766651e436aff192362621ce317704ea2f75d87e7be0f").unwrap()[..]).unwrap());
10172
10173                 assert_eq!(RevocationKey::from_basepoint(&secp_ctx, &RevocationBasepoint::from(base_point), &per_commitment_point).to_public_key().serialize()[..],
10174                                 <Vec<u8>>::from_hex("02916e326636d19c33f13e8c0c3a03dd157f332f3e99c317c141dd865eb01f8ff0").unwrap()[..]);
10175
10176                 assert_eq!(chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_secret, &base_secret),
10177                                 SecretKey::from_slice(&<Vec<u8>>::from_hex("d09ffff62ddb2297ab000cc85bcb4283fdeb6aa052affbc9dddcf33b61078110").unwrap()[..]).unwrap());
10178         }
10179
10180         #[test]
10181         fn test_zero_conf_channel_type_support() {
10182                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
10183                 let secp_ctx = Secp256k1::new();
10184                 let seed = [42; 32];
10185                 let network = Network::Testnet;
10186                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
10187                 let logger = test_utils::TestLogger::new();
10188
10189                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
10190                 let config = UserConfig::default();
10191                 let node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
10192                         node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None).unwrap();
10193
10194                 let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
10195                 channel_type_features.set_zero_conf_required();
10196
10197                 let mut open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10198                 open_channel_msg.channel_type = Some(channel_type_features);
10199                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10200                 let res = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider,
10201                         node_b_node_id, &channelmanager::provided_channel_type_features(&config),
10202                         &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false);
10203                 assert!(res.is_ok());
10204         }
10205
10206         #[test]
10207         fn test_supports_anchors_zero_htlc_tx_fee() {
10208                 // Tests that if both sides support and negotiate `anchors_zero_fee_htlc_tx`, it is the
10209                 // resulting `channel_type`.
10210                 let secp_ctx = Secp256k1::new();
10211                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
10212                 let network = Network::Testnet;
10213                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
10214                 let logger = test_utils::TestLogger::new();
10215
10216                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
10217                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
10218
10219                 let mut config = UserConfig::default();
10220                 config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
10221
10222                 // It is not enough for just the initiator to signal `option_anchors_zero_fee_htlc_tx`, both
10223                 // need to signal it.
10224                 let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10225                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10226                         &channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42,
10227                         &config, 0, 42, None
10228                 ).unwrap();
10229                 assert!(!channel_a.context.channel_type.supports_anchors_zero_fee_htlc_tx());
10230
10231                 let mut expected_channel_type = ChannelTypeFeatures::empty();
10232                 expected_channel_type.set_static_remote_key_required();
10233                 expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
10234
10235                 let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10236                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10237                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10238                         None
10239                 ).unwrap();
10240
10241                 let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10242                 let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
10243                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
10244                         &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
10245                         &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false
10246                 ).unwrap();
10247
10248                 assert_eq!(channel_a.context.channel_type, expected_channel_type);
10249                 assert_eq!(channel_b.context.channel_type, expected_channel_type);
10250         }
10251
10252         #[test]
10253         fn test_rejects_implicit_simple_anchors() {
10254                 // Tests that if `option_anchors` is being negotiated implicitly through the intersection of
10255                 // each side's `InitFeatures`, it is rejected.
10256                 let secp_ctx = Secp256k1::new();
10257                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
10258                 let network = Network::Testnet;
10259                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
10260                 let logger = test_utils::TestLogger::new();
10261
10262                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
10263                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
10264
10265                 let config = UserConfig::default();
10266
10267                 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
10268                 let static_remote_key_required: u64 = 1 << 12;
10269                 let simple_anchors_required: u64 = 1 << 20;
10270                 let raw_init_features = static_remote_key_required | simple_anchors_required;
10271                 let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
10272
10273                 let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10274                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10275                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10276                         None
10277                 ).unwrap();
10278
10279                 // Set `channel_type` to `None` to force the implicit feature negotiation.
10280                 let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10281                 open_channel_msg.channel_type = None;
10282
10283                 // Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
10284                 // `static_remote_key`, it will fail the channel.
10285                 let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
10286                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
10287                         &channelmanager::provided_channel_type_features(&config), &init_features_with_simple_anchors,
10288                         &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false
10289                 );
10290                 assert!(channel_b.is_err());
10291         }
10292
10293         #[test]
10294         fn test_rejects_simple_anchors_channel_type() {
10295                 // Tests that if `option_anchors` is being negotiated through the `channel_type` feature,
10296                 // it is rejected.
10297                 let secp_ctx = Secp256k1::new();
10298                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
10299                 let network = Network::Testnet;
10300                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
10301                 let logger = test_utils::TestLogger::new();
10302
10303                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
10304                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
10305
10306                 let config = UserConfig::default();
10307
10308                 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
10309                 let static_remote_key_required: u64 = 1 << 12;
10310                 let simple_anchors_required: u64 = 1 << 20;
10311                 let simple_anchors_raw_features = static_remote_key_required | simple_anchors_required;
10312                 let simple_anchors_init = InitFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
10313                 let simple_anchors_channel_type = ChannelTypeFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
10314                 assert!(!simple_anchors_init.requires_unknown_bits());
10315                 assert!(!simple_anchors_channel_type.requires_unknown_bits());
10316
10317                 // First, we'll try to open a channel between A and B where A requests a channel type for
10318                 // the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
10319                 // B as it's not supported by LDK.
10320                 let channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10321                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
10322                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42,
10323                         None
10324                 ).unwrap();
10325
10326                 let mut open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10327                 open_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
10328
10329                 let res = InboundV1Channel::<&TestKeysInterface>::new(
10330                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
10331                         &channelmanager::provided_channel_type_features(&config), &simple_anchors_init,
10332                         &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false
10333                 );
10334                 assert!(res.is_err());
10335
10336                 // Then, we'll try to open another channel where A requests a channel type for
10337                 // `anchors_zero_fee_htlc_tx`. B is malicious and tries to downgrade the channel type to the
10338                 // original `option_anchors` feature, which should be rejected by A as it's not supported by
10339                 // LDK.
10340                 let mut channel_a = OutboundV1Channel::<&TestKeysInterface>::new(
10341                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &simple_anchors_init,
10342                         10000000, 100000, 42, &config, 0, 42, None
10343                 ).unwrap();
10344
10345                 let open_channel_msg = channel_a.get_open_channel(ChainHash::using_genesis_block(network));
10346
10347                 let channel_b = InboundV1Channel::<&TestKeysInterface>::new(
10348                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
10349                         &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
10350                         &open_channel_msg, 7, &config, 0, &&logger, /*is_0conf=*/false
10351                 ).unwrap();
10352
10353                 let mut accept_channel_msg = channel_b.get_accept_channel_message();
10354                 accept_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
10355
10356                 let res = channel_a.accept_channel(
10357                         &accept_channel_msg, &config.channel_handshake_limits, &simple_anchors_init
10358                 );
10359                 assert!(res.is_err());
10360         }
10361
10362         #[test]
10363         fn test_waiting_for_batch() {
10364                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
10365                 let logger = test_utils::TestLogger::new();
10366                 let secp_ctx = Secp256k1::new();
10367                 let seed = [42; 32];
10368                 let network = Network::Testnet;
10369                 let best_block = BestBlock::from_network(network);
10370                 let chain_hash = ChainHash::using_genesis_block(network);
10371                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
10372
10373                 let mut config = UserConfig::default();
10374                 // Set trust_own_funding_0conf while ensuring we don't send channel_ready for a
10375                 // channel in a batch before all channels are ready.
10376                 config.channel_handshake_limits.trust_own_funding_0conf = true;
10377
10378                 // Create a channel from node a to node b that will be part of batch funding.
10379                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
10380                 let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(
10381                         &feeest,
10382                         &&keys_provider,
10383                         &&keys_provider,
10384                         node_b_node_id,
10385                         &channelmanager::provided_init_features(&config),
10386                         10000000,
10387                         100000,
10388                         42,
10389                         &config,
10390                         0,
10391                         42,
10392                         None
10393                 ).unwrap();
10394
10395                 let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network));
10396                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
10397                 let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(
10398                         &feeest,
10399                         &&keys_provider,
10400                         &&keys_provider,
10401                         node_b_node_id,
10402                         &channelmanager::provided_channel_type_features(&config),
10403                         &channelmanager::provided_init_features(&config),
10404                         &open_channel_msg,
10405                         7,
10406                         &config,
10407                         0,
10408                         &&logger,
10409                         true,  // Allow node b to send a 0conf channel_ready.
10410                 ).unwrap();
10411
10412                 let accept_channel_msg = node_b_chan.accept_inbound_channel();
10413                 node_a_chan.accept_channel(
10414                         &accept_channel_msg,
10415                         &config.channel_handshake_limits,
10416                         &channelmanager::provided_init_features(&config),
10417                 ).unwrap();
10418
10419                 // Fund the channel with a batch funding transaction.
10420                 let output_script = node_a_chan.context.get_funding_redeemscript();
10421                 let tx = Transaction {
10422                         version: 1,
10423                         lock_time: LockTime::ZERO,
10424                         input: Vec::new(),
10425                         output: vec![
10426                                 TxOut {
10427                                         value: 10000000, script_pubkey: output_script.clone(),
10428                                 },
10429                                 TxOut {
10430                                         value: 10000000, script_pubkey: Builder::new().into_script(),
10431                                 },
10432                         ]};
10433                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
10434                 let funding_created_msg = node_a_chan.get_funding_created(
10435                         tx.clone(), funding_outpoint, true, &&logger,
10436                 ).map_err(|_| ()).unwrap();
10437                 let (mut node_b_chan, funding_signed_msg, _) = node_b_chan.funding_created(
10438                         &funding_created_msg.unwrap(),
10439                         best_block,
10440                         &&keys_provider,
10441                         &&logger,
10442                 ).map_err(|_| ()).unwrap();
10443                 let node_b_updates = node_b_chan.monitor_updating_restored(
10444                         &&logger,
10445                         &&keys_provider,
10446                         chain_hash,
10447                         &config,
10448                         0,
10449                 );
10450
10451                 // Receive funding_signed, but the channel will be configured to hold sending channel_ready and
10452                 // broadcasting the funding transaction until the batch is ready.
10453                 let res = node_a_chan.funding_signed(
10454                         &funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger,
10455                 );
10456                 let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };
10457                 let node_a_updates = node_a_chan.monitor_updating_restored(
10458                         &&logger,
10459                         &&keys_provider,
10460                         chain_hash,
10461                         &config,
10462                         0,
10463                 );
10464                 // Our channel_ready shouldn't be sent yet, even with trust_own_funding_0conf set,
10465                 // as the funding transaction depends on all channels in the batch becoming ready.
10466                 assert!(node_a_updates.channel_ready.is_none());
10467                 assert!(node_a_updates.funding_broadcastable.is_none());
10468                 assert_eq!(node_a_chan.context.channel_state, ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));
10469
10470                 // It is possible to receive a 0conf channel_ready from the remote node.
10471                 node_a_chan.channel_ready(
10472                         &node_b_updates.channel_ready.unwrap(),
10473                         &&keys_provider,
10474                         chain_hash,
10475                         &config,
10476                         &best_block,
10477                         &&logger,
10478                 ).unwrap();
10479                 assert_eq!(
10480                         node_a_chan.context.channel_state,
10481                         ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH | AwaitingChannelReadyFlags::THEIR_CHANNEL_READY)
10482                 );
10483
10484                 // Clear the ChannelState::WaitingForBatch only when called by ChannelManager.
10485                 node_a_chan.set_batch_ready();
10486                 assert_eq!(node_a_chan.context.channel_state, ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::THEIR_CHANNEL_READY));
10487                 assert!(node_a_chan.check_get_channel_ready(0).is_some());
10488         }
10489 }