]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/ln/channel.rs
Add some tests of payment metadata being sent and received
[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::script::{Script,Builder};
11 use bitcoin::blockdata::transaction::{Transaction, EcdsaSighashType};
12 use bitcoin::util::sighash;
13 use bitcoin::consensus::encode;
14
15 use bitcoin::hashes::Hash;
16 use bitcoin::hashes::sha256::Hash as Sha256;
17 use bitcoin::hashes::sha256d::Hash as Sha256d;
18 use bitcoin::hash_types::{Txid, BlockHash};
19
20 use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE;
21 use bitcoin::secp256k1::{PublicKey,SecretKey};
22 use bitcoin::secp256k1::{Secp256k1,ecdsa::Signature};
23 use bitcoin::secp256k1;
24
25 use crate::ln::{PaymentPreimage, PaymentHash};
26 use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
27 use crate::ln::msgs;
28 use crate::ln::msgs::{DecodeError, OptionalField, DataLossProtect};
29 use crate::ln::script::{self, ShutdownScript};
30 use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
31 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};
32 use crate::ln::chan_utils;
33 use crate::ln::onion_utils::HTLCFailReason;
34 use crate::chain::BestBlock;
35 use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, LowerBoundedFeeEstimator};
36 use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, LATENCY_GRACE_PERIOD_BLOCKS, CLOSED_CHANNEL_UPDATE_ID};
37 use crate::chain::transaction::{OutPoint, TransactionData};
38 use crate::chain::keysinterface::{WriteableEcdsaChannelSigner, EntropySource, ChannelSigner, SignerProvider, NodeSigner, Recipient};
39 use crate::events::ClosureReason;
40 use crate::routing::gossip::NodeId;
41 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer, VecWriter};
42 use crate::util::logger::Logger;
43 use crate::util::errors::APIError;
44 use crate::util::config::{UserConfig, ChannelConfig, LegacyChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits};
45 use crate::util::scid_utils::scid_from_parts;
46
47 use crate::io;
48 use crate::prelude::*;
49 use core::{cmp,mem,fmt};
50 use core::ops::Deref;
51 #[cfg(any(test, fuzzing, debug_assertions))]
52 use crate::sync::Mutex;
53 use bitcoin::hashes::hex::ToHex;
54
55 #[cfg(test)]
56 pub struct ChannelValueStat {
57         pub value_to_self_msat: u64,
58         pub channel_value_msat: u64,
59         pub channel_reserve_msat: u64,
60         pub pending_outbound_htlcs_amount_msat: u64,
61         pub pending_inbound_htlcs_amount_msat: u64,
62         pub holding_cell_outbound_amount_msat: u64,
63         pub counterparty_max_htlc_value_in_flight_msat: u64, // outgoing
64         pub counterparty_dust_limit_msat: u64,
65 }
66
67 pub struct AvailableBalances {
68         /// The amount that would go to us if we close the channel, ignoring any on-chain fees.
69         pub balance_msat: u64,
70         /// Total amount available for our counterparty to send to us.
71         pub inbound_capacity_msat: u64,
72         /// Total amount available for us to send to our counterparty.
73         pub outbound_capacity_msat: u64,
74         /// The maximum value we can assign to the next outbound HTLC
75         pub next_outbound_htlc_limit_msat: u64,
76 }
77
78 #[derive(Debug, Clone, Copy, PartialEq)]
79 enum FeeUpdateState {
80         // Inbound states mirroring InboundHTLCState
81         RemoteAnnounced,
82         AwaitingRemoteRevokeToAnnounce,
83         // Note that we do not have a AwaitingAnnouncedRemoteRevoke variant here as it is universally
84         // handled the same as `Committed`, with the only exception in `InboundHTLCState` being the
85         // distinction of when we allow ourselves to forward the HTLC. Because we aren't "forwarding"
86         // the fee update anywhere, we can simply consider the fee update `Committed` immediately
87         // instead of setting it to AwaitingAnnouncedRemoteRevoke.
88
89         // Outbound state can only be `LocalAnnounced` or `Committed`
90         Outbound,
91 }
92
93 enum InboundHTLCRemovalReason {
94         FailRelay(msgs::OnionErrorPacket),
95         FailMalformed(([u8; 32], u16)),
96         Fulfill(PaymentPreimage),
97 }
98
99 enum InboundHTLCState {
100         /// Offered by remote, to be included in next local commitment tx. I.e., the remote sent an
101         /// update_add_htlc message for this HTLC.
102         RemoteAnnounced(PendingHTLCStatus),
103         /// Included in a received commitment_signed message (implying we've
104         /// revoke_and_ack'd it), but the remote hasn't yet revoked their previous
105         /// state (see the example below). We have not yet included this HTLC in a
106         /// commitment_signed message because we are waiting on the remote's
107         /// aforementioned state revocation. One reason this missing remote RAA
108         /// (revoke_and_ack) blocks us from constructing a commitment_signed message
109         /// is because every time we create a new "state", i.e. every time we sign a
110         /// new commitment tx (see [BOLT #2]), we need a new per_commitment_point,
111         /// which are provided one-at-a-time in each RAA. E.g., the last RAA they
112         /// sent provided the per_commitment_point for our current commitment tx.
113         /// The other reason we should not send a commitment_signed without their RAA
114         /// is because their RAA serves to ACK our previous commitment_signed.
115         ///
116         /// Here's an example of how an HTLC could come to be in this state:
117         /// remote --> update_add_htlc(prev_htlc)   --> local
118         /// remote --> commitment_signed(prev_htlc) --> local
119         /// remote <-- revoke_and_ack               <-- local
120         /// remote <-- commitment_signed(prev_htlc) <-- local
121         /// [note that here, the remote does not respond with a RAA]
122         /// remote --> update_add_htlc(this_htlc)   --> local
123         /// remote --> commitment_signed(prev_htlc, this_htlc) --> local
124         /// Now `this_htlc` will be assigned this state. It's unable to be officially
125         /// accepted, i.e. included in a commitment_signed, because we're missing the
126         /// RAA that provides our next per_commitment_point. The per_commitment_point
127         /// is used to derive commitment keys, which are used to construct the
128         /// signatures in a commitment_signed message.
129         /// Implies AwaitingRemoteRevoke.
130         ///
131         /// [BOLT #2]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
132         AwaitingRemoteRevokeToAnnounce(PendingHTLCStatus),
133         /// Included in a received commitment_signed message (implying we've revoke_and_ack'd it).
134         /// We have also included this HTLC in our latest commitment_signed and are now just waiting
135         /// on the remote's revoke_and_ack to make this HTLC an irrevocable part of the state of the
136         /// channel (before it can then get forwarded and/or removed).
137         /// Implies AwaitingRemoteRevoke.
138         AwaitingAnnouncedRemoteRevoke(PendingHTLCStatus),
139         Committed,
140         /// Removed by us and a new commitment_signed was sent (if we were AwaitingRemoteRevoke when we
141         /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
142         /// we'll drop it.
143         /// Note that we have to keep an eye on the HTLC until we've received a broadcastable
144         /// commitment transaction without it as otherwise we'll have to force-close the channel to
145         /// claim it before the timeout (obviously doesn't apply to revoked HTLCs that we can't claim
146         /// anyway). That said, ChannelMonitor does this for us (see
147         /// ChannelMonitor::should_broadcast_holder_commitment_txn) so we actually remove the HTLC from
148         /// our own local state before then, once we're sure that the next commitment_signed and
149         /// ChannelMonitor::provide_latest_local_commitment_tx will not include this HTLC.
150         LocalRemoved(InboundHTLCRemovalReason),
151 }
152
153 struct InboundHTLCOutput {
154         htlc_id: u64,
155         amount_msat: u64,
156         cltv_expiry: u32,
157         payment_hash: PaymentHash,
158         state: InboundHTLCState,
159 }
160
161 enum OutboundHTLCState {
162         /// Added by us and included in a commitment_signed (if we were AwaitingRemoteRevoke when we
163         /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
164         /// we will promote to Committed (note that they may not accept it until the next time we
165         /// revoke, but we don't really care about that:
166         ///  * they've revoked, so worst case we can announce an old state and get our (option on)
167         ///    money back (though we won't), and,
168         ///  * we'll send them a revoke when they send a commitment_signed, and since only they're
169         ///    allowed to remove it, the "can only be removed once committed on both sides" requirement
170         ///    doesn't matter to us and it's up to them to enforce it, worst-case they jump ahead but
171         ///    we'll never get out of sync).
172         /// Note that we Box the OnionPacket as it's rather large and we don't want to blow up
173         /// OutboundHTLCOutput's size just for a temporary bit
174         LocalAnnounced(Box<msgs::OnionPacket>),
175         Committed,
176         /// Remote removed this (outbound) HTLC. We're waiting on their commitment_signed to finalize
177         /// the change (though they'll need to revoke before we fail the payment).
178         RemoteRemoved(OutboundHTLCOutcome),
179         /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
180         /// the remote side hasn't yet revoked their previous state, which we need them to do before we
181         /// can do any backwards failing. Implies AwaitingRemoteRevoke.
182         /// We also have not yet removed this HTLC in a commitment_signed message, and are waiting on a
183         /// remote revoke_and_ack on a previous state before we can do so.
184         AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome),
185         /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
186         /// the remote side hasn't yet revoked their previous state, which we need them to do before we
187         /// can do any backwards failing. Implies AwaitingRemoteRevoke.
188         /// We have removed this HTLC in our latest commitment_signed and are now just waiting on a
189         /// revoke_and_ack to drop completely.
190         AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome),
191 }
192
193 #[derive(Clone)]
194 enum OutboundHTLCOutcome {
195         /// LDK version 0.0.105+ will always fill in the preimage here.
196         Success(Option<PaymentPreimage>),
197         Failure(HTLCFailReason),
198 }
199
200 impl From<Option<HTLCFailReason>> for OutboundHTLCOutcome {
201         fn from(o: Option<HTLCFailReason>) -> Self {
202                 match o {
203                         None => OutboundHTLCOutcome::Success(None),
204                         Some(r) => OutboundHTLCOutcome::Failure(r)
205                 }
206         }
207 }
208
209 impl<'a> Into<Option<&'a HTLCFailReason>> for &'a OutboundHTLCOutcome {
210         fn into(self) -> Option<&'a HTLCFailReason> {
211                 match self {
212                         OutboundHTLCOutcome::Success(_) => None,
213                         OutboundHTLCOutcome::Failure(ref r) => Some(r)
214                 }
215         }
216 }
217
218 struct OutboundHTLCOutput {
219         htlc_id: u64,
220         amount_msat: u64,
221         cltv_expiry: u32,
222         payment_hash: PaymentHash,
223         state: OutboundHTLCState,
224         source: HTLCSource,
225 }
226
227 /// See AwaitingRemoteRevoke ChannelState for more info
228 enum HTLCUpdateAwaitingACK {
229         AddHTLC { // TODO: Time out if we're getting close to cltv_expiry
230                 // always outbound
231                 amount_msat: u64,
232                 cltv_expiry: u32,
233                 payment_hash: PaymentHash,
234                 source: HTLCSource,
235                 onion_routing_packet: msgs::OnionPacket,
236         },
237         ClaimHTLC {
238                 payment_preimage: PaymentPreimage,
239                 htlc_id: u64,
240         },
241         FailHTLC {
242                 htlc_id: u64,
243                 err_packet: msgs::OnionErrorPacket,
244         },
245 }
246
247 /// There are a few "states" and then a number of flags which can be applied:
248 /// We first move through init with OurInitSent -> TheirInitSent -> FundingCreated -> FundingSent.
249 /// TheirChannelReady and OurChannelReady then get set on FundingSent, and when both are set we
250 /// move on to ChannelReady.
251 /// Note that PeerDisconnected can be set on both ChannelReady and FundingSent.
252 /// ChannelReady can then get all remaining flags set on it, until we finish shutdown, then we
253 /// move on to ShutdownComplete, at which point most calls into this channel are disallowed.
254 enum ChannelState {
255         /// Implies we have (or are prepared to) send our open_channel/accept_channel message
256         OurInitSent = 1 << 0,
257         /// Implies we have received their open_channel/accept_channel message
258         TheirInitSent = 1 << 1,
259         /// We have sent funding_created and are awaiting a funding_signed to advance to FundingSent.
260         /// Note that this is nonsense for an inbound channel as we immediately generate funding_signed
261         /// upon receipt of funding_created, so simply skip this state.
262         FundingCreated = 4,
263         /// Set when we have received/sent funding_created and funding_signed and are thus now waiting
264         /// on the funding transaction to confirm. The ChannelReady flags are set to indicate when we
265         /// and our counterparty consider the funding transaction confirmed.
266         FundingSent = 8,
267         /// Flag which can be set on FundingSent to indicate they sent us a channel_ready message.
268         /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelReady.
269         TheirChannelReady = 1 << 4,
270         /// Flag which can be set on FundingSent to indicate we sent them a channel_ready message.
271         /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelReady.
272         OurChannelReady = 1 << 5,
273         ChannelReady = 64,
274         /// Flag which is set on ChannelReady and FundingSent indicating remote side is considered
275         /// "disconnected" and no updates are allowed until after we've done a channel_reestablish
276         /// dance.
277         PeerDisconnected = 1 << 7,
278         /// Flag which is set on ChannelReady, FundingCreated, and FundingSent indicating the user has
279         /// told us a ChannelMonitor update is pending async persistence somewhere and we should pause
280         /// sending any outbound messages until they've managed to finish.
281         MonitorUpdateInProgress = 1 << 8,
282         /// Flag which implies that we have sent a commitment_signed but are awaiting the responding
283         /// revoke_and_ack message. During this time period, we can't generate new commitment_signed
284         /// messages as then we will be unable to determine which HTLCs they included in their
285         /// revoke_and_ack implicit ACK, so instead we have to hold them away temporarily to be sent
286         /// later.
287         /// Flag is set on ChannelReady.
288         AwaitingRemoteRevoke = 1 << 9,
289         /// Flag which is set on ChannelReady or FundingSent after receiving a shutdown message from
290         /// the remote end. If set, they may not add any new HTLCs to the channel, and we are expected
291         /// to respond with our own shutdown message when possible.
292         RemoteShutdownSent = 1 << 10,
293         /// Flag which is set on ChannelReady or FundingSent after sending a shutdown message. At this
294         /// point, we may not add any new HTLCs to the channel.
295         LocalShutdownSent = 1 << 11,
296         /// We've successfully negotiated a closing_signed dance. At this point ChannelManager is about
297         /// to drop us, but we store this anyway.
298         ShutdownComplete = 4096,
299 }
300 const BOTH_SIDES_SHUTDOWN_MASK: u32 = ChannelState::LocalShutdownSent as u32 | ChannelState::RemoteShutdownSent as u32;
301 const MULTI_STATE_FLAGS: u32 = BOTH_SIDES_SHUTDOWN_MASK | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32;
302
303 pub const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
304
305 /// The "channel disabled" bit in channel_update must be set based on whether we are connected to
306 /// our counterparty or not. However, we don't want to announce updates right away to avoid
307 /// spamming the network with updates if the connection is flapping. Instead, we "stage" updates to
308 /// our channel_update message and track the current state here.
309 /// See implementation at [`super::channelmanager::ChannelManager::timer_tick_occurred`].
310 #[derive(Clone, Copy, PartialEq)]
311 pub(super) enum ChannelUpdateStatus {
312         /// We've announced the channel as enabled and are connected to our peer.
313         Enabled,
314         /// Our channel is no longer live, but we haven't announced the channel as disabled yet.
315         DisabledStaged,
316         /// Our channel is live again, but we haven't announced the channel as enabled yet.
317         EnabledStaged,
318         /// We've announced the channel as disabled.
319         Disabled,
320 }
321
322 /// We track when we sent an `AnnouncementSignatures` to our peer in a few states, described here.
323 #[derive(PartialEq)]
324 pub enum AnnouncementSigsState {
325         /// We have not sent our peer an `AnnouncementSignatures` yet, or our peer disconnected since
326         /// we sent the last `AnnouncementSignatures`.
327         NotSent,
328         /// We sent an `AnnouncementSignatures` to our peer since the last time our peer disconnected.
329         /// This state never appears on disk - instead we write `NotSent`.
330         MessageSent,
331         /// We sent a `CommitmentSigned` after the last `AnnouncementSignatures` we sent. Because we
332         /// only ever have a single `CommitmentSigned` pending at once, if we sent one after sending
333         /// `AnnouncementSignatures` then we know the peer received our `AnnouncementSignatures` if
334         /// they send back a `RevokeAndACK`.
335         /// This state never appears on disk - instead we write `NotSent`.
336         Committed,
337         /// We received a `RevokeAndACK`, effectively ack-ing our `AnnouncementSignatures`, at this
338         /// point we no longer need to re-send our `AnnouncementSignatures` again on reconnect.
339         PeerReceived,
340 }
341
342 /// An enum indicating whether the local or remote side offered a given HTLC.
343 enum HTLCInitiator {
344         LocalOffered,
345         RemoteOffered,
346 }
347
348 /// An enum gathering stats on pending HTLCs, either inbound or outbound side.
349 struct HTLCStats {
350         pending_htlcs: u32,
351         pending_htlcs_value_msat: u64,
352         on_counterparty_tx_dust_exposure_msat: u64,
353         on_holder_tx_dust_exposure_msat: u64,
354         holding_cell_msat: u64,
355         on_holder_tx_holding_cell_htlcs_count: u32, // dust HTLCs *non*-included
356 }
357
358 /// An enum gathering stats on commitment transaction, either local or remote.
359 struct CommitmentStats<'a> {
360         tx: CommitmentTransaction, // the transaction info
361         feerate_per_kw: u32, // the feerate included to build the transaction
362         total_fee_sat: u64, // the total fee included in the transaction
363         num_nondust_htlcs: usize,  // the number of HTLC outputs (dust HTLCs *non*-included)
364         htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, // the list of HTLCs (dust HTLCs *included*) which were not ignored when building the transaction
365         local_balance_msat: u64, // local balance before fees but considering dust limits
366         remote_balance_msat: u64, // remote balance before fees but considering dust limits
367         preimages: Vec<PaymentPreimage>, // preimages for successful offered HTLCs since last commitment
368 }
369
370 /// Used when calculating whether we or the remote can afford an additional HTLC.
371 struct HTLCCandidate {
372         amount_msat: u64,
373         origin: HTLCInitiator,
374 }
375
376 impl HTLCCandidate {
377         fn new(amount_msat: u64, origin: HTLCInitiator) -> Self {
378                 Self {
379                         amount_msat,
380                         origin,
381                 }
382         }
383 }
384
385 /// A return value enum for get_update_fulfill_htlc. See UpdateFulfillCommitFetch variants for
386 /// description
387 enum UpdateFulfillFetch {
388         NewClaim {
389                 monitor_update: ChannelMonitorUpdate,
390                 htlc_value_msat: u64,
391                 msg: Option<msgs::UpdateFulfillHTLC>,
392         },
393         DuplicateClaim {},
394 }
395
396 /// The return type of get_update_fulfill_htlc_and_commit.
397 pub enum UpdateFulfillCommitFetch<'a> {
398         /// Indicates the HTLC fulfill is new, and either generated an update_fulfill message, placed
399         /// it in the holding cell, or re-generated the update_fulfill message after the same claim was
400         /// previously placed in the holding cell (and has since been removed).
401         NewClaim {
402                 /// The ChannelMonitorUpdate which places the new payment preimage in the channel monitor
403                 monitor_update: &'a ChannelMonitorUpdate,
404                 /// The value of the HTLC which was claimed, in msat.
405                 htlc_value_msat: u64,
406         },
407         /// Indicates the HTLC fulfill is duplicative and already existed either in the holding cell
408         /// or has been forgotten (presumably previously claimed).
409         DuplicateClaim {},
410 }
411
412 /// The return value of `monitor_updating_restored`
413 pub(super) struct MonitorRestoreUpdates {
414         pub raa: Option<msgs::RevokeAndACK>,
415         pub commitment_update: Option<msgs::CommitmentUpdate>,
416         pub order: RAACommitmentOrder,
417         pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
418         pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
419         pub finalized_claimed_htlcs: Vec<HTLCSource>,
420         pub funding_broadcastable: Option<Transaction>,
421         pub channel_ready: Option<msgs::ChannelReady>,
422         pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
423 }
424
425 /// The return value of `channel_reestablish`
426 pub(super) struct ReestablishResponses {
427         pub channel_ready: Option<msgs::ChannelReady>,
428         pub raa: Option<msgs::RevokeAndACK>,
429         pub commitment_update: Option<msgs::CommitmentUpdate>,
430         pub order: RAACommitmentOrder,
431         pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
432         pub shutdown_msg: Option<msgs::Shutdown>,
433 }
434
435 /// If the majority of the channels funds are to the fundee and the initiator holds only just
436 /// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
437 /// initiator controls the feerate, if they then go to increase the channel fee, they may have no
438 /// balance but the fundee is unable to send a payment as the increase in fee more than drains
439 /// their reserve value. Thus, neither side can send a new HTLC and the channel becomes useless.
440 /// Thus, before sending an HTLC when we are the initiator, we check that the feerate can increase
441 /// by this multiple without hitting this case, before sending.
442 /// This multiple is effectively the maximum feerate "jump" we expect until more HTLCs flow over
443 /// the channel. Sadly, there isn't really a good number for this - if we expect to have no new
444 /// HTLCs for days we may need this to suffice for feerate increases across days, but that may
445 /// leave the channel less usable as we hold a bigger reserve.
446 #[cfg(any(fuzzing, test))]
447 pub const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
448 #[cfg(not(any(fuzzing, test)))]
449 const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
450
451 /// If we fail to see a funding transaction confirmed on-chain within this many blocks after the
452 /// channel creation on an inbound channel, we simply force-close and move on.
453 /// This constant is the one suggested in BOLT 2.
454 pub(crate) const FUNDING_CONF_DEADLINE_BLOCKS: u32 = 2016;
455
456 /// In case of a concurrent update_add_htlc proposed by our counterparty, we might
457 /// not have enough balance value remaining to cover the onchain cost of this new
458 /// HTLC weight. If this happens, our counterparty fails the reception of our
459 /// commitment_signed including this new HTLC due to infringement on the channel
460 /// reserve.
461 /// To prevent this case, we compute our outbound update_fee with an HTLC buffer of
462 /// size 2. However, if the number of concurrent update_add_htlc is higher, this still
463 /// leads to a channel force-close. Ultimately, this is an issue coming from the
464 /// design of LN state machines, allowing asynchronous updates.
465 pub(crate) const CONCURRENT_INBOUND_HTLC_FEE_BUFFER: u32 = 2;
466
467 /// When a channel is opened, we check that the funding amount is enough to pay for relevant
468 /// commitment transaction fees, with at least this many HTLCs present on the commitment
469 /// transaction (not counting the value of the HTLCs themselves).
470 pub(crate) const MIN_AFFORDABLE_HTLC_COUNT: usize = 4;
471
472 /// When a [`Channel`] has its [`ChannelConfig`] updated, its existing one is stashed for up to this
473 /// number of ticks to allow forwarding HTLCs by nodes that have yet to receive the new
474 /// ChannelUpdate prompted by the config update. This value was determined as follows:
475 ///
476 ///   * The expected interval between ticks (1 minute).
477 ///   * The average convergence delay of updates across the network, i.e., ~300 seconds on average
478 ///      for a node to see an update as seen on `<https://arxiv.org/pdf/2205.12737.pdf>`.
479 ///   * `EXPIRE_PREV_CONFIG_TICKS` = convergence_delay / tick_interval
480 pub(crate) const EXPIRE_PREV_CONFIG_TICKS: usize = 5;
481
482 // TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
483 // has been completed, and then turn into a Channel to get compiler-time enforcement of things like
484 // calling channel_id() before we're set up or things like get_outbound_funding_signed on an
485 // inbound channel.
486 //
487 // Holder designates channel data owned for the benefice of the user client.
488 // Counterparty designates channel data owned by the another channel participant entity.
489 pub(super) struct Channel<Signer: ChannelSigner> {
490         config: LegacyChannelConfig,
491
492         // Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
493         // constructed using it. The second element in the tuple corresponds to the number of ticks that
494         // have elapsed since the update occurred.
495         prev_config: Option<(ChannelConfig, usize)>,
496
497         inbound_handshake_limits_override: Option<ChannelHandshakeLimits>,
498
499         user_id: u128,
500
501         channel_id: [u8; 32],
502         temporary_channel_id: Option<[u8; 32]>, // Will be `None` for channels created prior to 0.0.115.
503         channel_state: u32,
504
505         // When we reach max(6 blocks, minimum_depth), we need to send an AnnouncementSigs message to
506         // our peer. However, we want to make sure they received it, or else rebroadcast it when we
507         // next connect.
508         // We do so here, see `AnnouncementSigsSent` for more details on the state(s).
509         // Note that a number of our tests were written prior to the behavior here which retransmits
510         // AnnouncementSignatures until after an RAA completes, so the behavior is short-circuited in
511         // many tests.
512         #[cfg(any(test, feature = "_test_utils"))]
513         pub(crate) announcement_sigs_state: AnnouncementSigsState,
514         #[cfg(not(any(test, feature = "_test_utils")))]
515         announcement_sigs_state: AnnouncementSigsState,
516
517         secp_ctx: Secp256k1<secp256k1::All>,
518         channel_value_satoshis: u64,
519
520         latest_monitor_update_id: u64,
521
522         holder_signer: Signer,
523         shutdown_scriptpubkey: Option<ShutdownScript>,
524         destination_script: Script,
525
526         // Our commitment numbers start at 2^48-1 and count down, whereas the ones used in transaction
527         // generation start at 0 and count up...this simplifies some parts of implementation at the
528         // cost of others, but should really just be changed.
529
530         cur_holder_commitment_transaction_number: u64,
531         cur_counterparty_commitment_transaction_number: u64,
532         value_to_self_msat: u64, // Excluding all pending_htlcs, excluding fees
533         pending_inbound_htlcs: Vec<InboundHTLCOutput>,
534         pending_outbound_htlcs: Vec<OutboundHTLCOutput>,
535         holding_cell_htlc_updates: Vec<HTLCUpdateAwaitingACK>,
536
537         /// When resending CS/RAA messages on channel monitor restoration or on reconnect, we always
538         /// need to ensure we resend them in the order we originally generated them. Note that because
539         /// there can only ever be one in-flight CS and/or one in-flight RAA at any time, it is
540         /// sufficient to simply set this to the opposite of any message we are generating as we
541         /// generate it. ie when we generate a CS, we set this to RAAFirst as, if there is a pending
542         /// in-flight RAA to resend, it will have been the first thing we generated, and thus we should
543         /// send it first.
544         resend_order: RAACommitmentOrder,
545
546         monitor_pending_channel_ready: bool,
547         monitor_pending_revoke_and_ack: bool,
548         monitor_pending_commitment_signed: bool,
549
550         // TODO: If a channel is drop'd, we don't know whether the `ChannelMonitor` is ultimately
551         // responsible for some of the HTLCs here or not - we don't know whether the update in question
552         // completed or not. We currently ignore these fields entirely when force-closing a channel,
553         // but need to handle this somehow or we run the risk of losing HTLCs!
554         monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
555         monitor_pending_failures: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
556         monitor_pending_finalized_fulfills: Vec<HTLCSource>,
557
558         // pending_update_fee is filled when sending and receiving update_fee.
559         //
560         // Because it follows the same commitment flow as HTLCs, `FeeUpdateState` is either `Outbound`
561         // or matches a subset of the `InboundHTLCOutput` variants. It is then updated/used when
562         // generating new commitment transactions with exactly the same criteria as inbound/outbound
563         // HTLCs with similar state.
564         pending_update_fee: Option<(u32, FeeUpdateState)>,
565         // If a `send_update_fee()` call is made with ChannelState::AwaitingRemoteRevoke set, we place
566         // it here instead of `pending_update_fee` in the same way as we place outbound HTLC updates in
567         // `holding_cell_htlc_updates` instead of `pending_outbound_htlcs`. It is released into
568         // `pending_update_fee` with the same criteria as outbound HTLC updates but can be updated by
569         // further `send_update_fee` calls, dropping the previous holding cell update entirely.
570         holding_cell_update_fee: Option<u32>,
571         next_holder_htlc_id: u64,
572         next_counterparty_htlc_id: u64,
573         feerate_per_kw: u32,
574
575         /// The timestamp set on our latest `channel_update` message for this channel. It is updated
576         /// when the channel is updated in ways which may impact the `channel_update` message or when a
577         /// new block is received, ensuring it's always at least moderately close to the current real
578         /// time.
579         update_time_counter: u32,
580
581         #[cfg(debug_assertions)]
582         /// Max to_local and to_remote outputs in a locally-generated commitment transaction
583         holder_max_commitment_tx_output: Mutex<(u64, u64)>,
584         #[cfg(debug_assertions)]
585         /// Max to_local and to_remote outputs in a remote-generated commitment transaction
586         counterparty_max_commitment_tx_output: Mutex<(u64, u64)>,
587
588         last_sent_closing_fee: Option<(u64, Signature)>, // (fee, holder_sig)
589         target_closing_feerate_sats_per_kw: Option<u32>,
590
591         /// If our counterparty sent us a closing_signed while we were waiting for a `ChannelMonitor`
592         /// update, we need to delay processing it until later. We do that here by simply storing the
593         /// closing_signed message and handling it in `maybe_propose_closing_signed`.
594         pending_counterparty_closing_signed: Option<msgs::ClosingSigned>,
595
596         /// The minimum and maximum absolute fee, in satoshis, we are willing to place on the closing
597         /// transaction. These are set once we reach `closing_negotiation_ready`.
598         #[cfg(test)]
599         pub(crate) closing_fee_limits: Option<(u64, u64)>,
600         #[cfg(not(test))]
601         closing_fee_limits: Option<(u64, u64)>,
602
603         /// Flag that ensures that `accept_inbound_channel` must be called before `funding_created`
604         /// is executed successfully. The reason for this flag is that when the
605         /// `UserConfig::manually_accept_inbound_channels` config flag is set to true, inbound channels
606         /// are required to be manually accepted by the node operator before the `msgs::AcceptChannel`
607         /// message is created and sent out. During the manual accept process, `accept_inbound_channel`
608         /// is called by `ChannelManager::accept_inbound_channel`.
609         ///
610         /// The flag counteracts that a counterparty node could theoretically send a
611         /// `msgs::FundingCreated` message before the node operator has manually accepted an inbound
612         /// channel request made by the counterparty node. That would execute `funding_created` before
613         /// `accept_inbound_channel`, and `funding_created` should therefore not execute successfully.
614         inbound_awaiting_accept: bool,
615
616         /// The hash of the block in which the funding transaction was included.
617         funding_tx_confirmed_in: Option<BlockHash>,
618         funding_tx_confirmation_height: u32,
619         short_channel_id: Option<u64>,
620         /// Either the height at which this channel was created or the height at which it was last
621         /// serialized if it was serialized by versions prior to 0.0.103.
622         /// We use this to close if funding is never broadcasted.
623         channel_creation_height: u32,
624
625         counterparty_dust_limit_satoshis: u64,
626
627         #[cfg(test)]
628         pub(super) holder_dust_limit_satoshis: u64,
629         #[cfg(not(test))]
630         holder_dust_limit_satoshis: u64,
631
632         #[cfg(test)]
633         pub(super) counterparty_max_htlc_value_in_flight_msat: u64,
634         #[cfg(not(test))]
635         counterparty_max_htlc_value_in_flight_msat: u64,
636
637         #[cfg(test)]
638         pub(super) holder_max_htlc_value_in_flight_msat: u64,
639         #[cfg(not(test))]
640         holder_max_htlc_value_in_flight_msat: u64,
641
642         /// minimum channel reserve for self to maintain - set by them.
643         counterparty_selected_channel_reserve_satoshis: Option<u64>,
644
645         #[cfg(test)]
646         pub(super) holder_selected_channel_reserve_satoshis: u64,
647         #[cfg(not(test))]
648         holder_selected_channel_reserve_satoshis: u64,
649
650         counterparty_htlc_minimum_msat: u64,
651         holder_htlc_minimum_msat: u64,
652         #[cfg(test)]
653         pub counterparty_max_accepted_htlcs: u16,
654         #[cfg(not(test))]
655         counterparty_max_accepted_htlcs: u16,
656         //implied by OUR_MAX_HTLCS: max_accepted_htlcs: u16,
657         minimum_depth: Option<u32>,
658
659         counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,
660
661         pub(crate) channel_transaction_parameters: ChannelTransactionParameters,
662         funding_transaction: Option<Transaction>,
663
664         counterparty_cur_commitment_point: Option<PublicKey>,
665         counterparty_prev_commitment_point: Option<PublicKey>,
666         counterparty_node_id: PublicKey,
667
668         counterparty_shutdown_scriptpubkey: Option<Script>,
669
670         commitment_secrets: CounterpartyCommitmentSecrets,
671
672         channel_update_status: ChannelUpdateStatus,
673         /// Once we reach `closing_negotiation_ready`, we set this, indicating if closing_signed does
674         /// not complete within a single timer tick (one minute), we should force-close the channel.
675         /// This prevents us from keeping unusable channels around forever if our counterparty wishes
676         /// to DoS us.
677         /// Note that this field is reset to false on deserialization to give us a chance to connect to
678         /// our peer and start the closing_signed negotiation fresh.
679         closing_signed_in_flight: bool,
680
681         /// Our counterparty's channel_announcement signatures provided in announcement_signatures.
682         /// This can be used to rebroadcast the channel_announcement message later.
683         announcement_sigs: Option<(Signature, Signature)>,
684
685         // We save these values so we can make sure `next_local_commit_tx_fee_msat` and
686         // `next_remote_commit_tx_fee_msat` properly predict what the next commitment transaction fee will
687         // be, by comparing the cached values to the fee of the tranaction generated by
688         // `build_commitment_transaction`.
689         #[cfg(any(test, fuzzing))]
690         next_local_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
691         #[cfg(any(test, fuzzing))]
692         next_remote_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
693
694         /// lnd has a long-standing bug where, upon reconnection, if the channel is not yet confirmed
695         /// they will not send a channel_reestablish until the channel locks in. Then, they will send a
696         /// channel_ready *before* sending the channel_reestablish (which is clearly a violation of
697         /// the BOLT specs). We copy c-lightning's workaround here and simply store the channel_ready
698         /// message until we receive a channel_reestablish.
699         ///
700         /// See-also <https://github.com/lightningnetwork/lnd/issues/4006>
701         pub workaround_lnd_bug_4006: Option<msgs::ChannelReady>,
702
703         #[cfg(any(test, fuzzing))]
704         // When we receive an HTLC fulfill on an outbound path, we may immediately fulfill the
705         // corresponding HTLC on the inbound path. If, then, the outbound path channel is
706         // disconnected and reconnected (before we've exchange commitment_signed and revoke_and_ack
707         // messages), they may re-broadcast their update_fulfill_htlc, causing a duplicate claim. This
708         // is fine, but as a sanity check in our failure to generate the second claim, we check here
709         // that the original was a claim, and that we aren't now trying to fulfill a failed HTLC.
710         historical_inbound_htlc_fulfills: HashSet<u64>,
711
712         /// This channel's type, as negotiated during channel open
713         channel_type: ChannelTypeFeatures,
714
715         // Our counterparty can offer us SCID aliases which they will map to this channel when routing
716         // outbound payments. These can be used in invoice route hints to avoid explicitly revealing
717         // the channel's funding UTXO.
718         //
719         // We also use this when sending our peer a channel_update that isn't to be broadcasted
720         // publicly - allowing them to re-use their map of SCID -> channel for channel_update ->
721         // associated channel mapping.
722         //
723         // We only bother storing the most recent SCID alias at any time, though our counterparty has
724         // to store all of them.
725         latest_inbound_scid_alias: Option<u64>,
726
727         // We always offer our counterparty a static SCID alias, which we recognize as for this channel
728         // if we see it in HTLC forwarding instructions. We don't bother rotating the alias given we
729         // don't currently support node id aliases and eventually privacy should be provided with
730         // blinded paths instead of simple scid+node_id aliases.
731         outbound_scid_alias: u64,
732
733         // We track whether we already emitted a `ChannelPending` event.
734         channel_pending_event_emitted: bool,
735
736         // We track whether we already emitted a `ChannelReady` event.
737         channel_ready_event_emitted: bool,
738
739         /// The unique identifier used to re-derive the private key material for the channel through
740         /// [`SignerProvider::derive_channel_signer`].
741         channel_keys_id: [u8; 32],
742
743         /// When we generate [`ChannelMonitorUpdate`]s to persist, they may not be persisted immediately.
744         /// If we then persist the [`channelmanager::ChannelManager`] and crash before the persistence
745         /// completes we still need to be able to complete the persistence. Thus, we have to keep a
746         /// copy of the [`ChannelMonitorUpdate`] here until it is complete.
747         pending_monitor_updates: Vec<ChannelMonitorUpdate>,
748 }
749
750 #[cfg(any(test, fuzzing))]
751 struct CommitmentTxInfoCached {
752         fee: u64,
753         total_pending_htlcs: usize,
754         next_holder_htlc_id: u64,
755         next_counterparty_htlc_id: u64,
756         feerate: u32,
757 }
758
759 pub const OUR_MAX_HTLCS: u16 = 50; //TODO
760
761 pub(crate) fn commitment_tx_base_weight(opt_anchors: bool) -> u64 {
762         const COMMITMENT_TX_BASE_WEIGHT: u64 = 724;
763         const COMMITMENT_TX_BASE_ANCHOR_WEIGHT: u64 = 1124;
764         if opt_anchors { COMMITMENT_TX_BASE_ANCHOR_WEIGHT } else { COMMITMENT_TX_BASE_WEIGHT }
765 }
766
767 #[cfg(not(test))]
768 const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
769 #[cfg(test)]
770 pub const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
771
772 pub const ANCHOR_OUTPUT_VALUE_SATOSHI: u64 = 330;
773
774 /// The percentage of the channel value `holder_max_htlc_value_in_flight_msat` used to be set to,
775 /// before this was made configurable. The percentage was made configurable in LDK 0.0.107,
776 /// although LDK 0.0.104+ enabled serialization of channels with a different value set for
777 /// `holder_max_htlc_value_in_flight_msat`.
778 pub const MAX_IN_FLIGHT_PERCENT_LEGACY: u8 = 10;
779
780 /// Maximum `funding_satoshis` value according to the BOLT #2 specification, if
781 /// `option_support_large_channel` (aka wumbo channels) is not supported.
782 /// It's 2^24 - 1.
783 pub const MAX_FUNDING_SATOSHIS_NO_WUMBO: u64 = (1 << 24) - 1;
784
785 /// Total bitcoin supply in satoshis.
786 pub const TOTAL_BITCOIN_SUPPLY_SATOSHIS: u64 = 21_000_000 * 1_0000_0000;
787
788 /// The maximum network dust limit for standard script formats. This currently represents the
789 /// minimum output value for a P2SH output before Bitcoin Core 22 considers the entire
790 /// transaction non-standard and thus refuses to relay it.
791 /// We also use this as the maximum counterparty `dust_limit_satoshis` allowed, given many
792 /// implementations use this value for their dust limit today.
793 pub const MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS: u64 = 546;
794
795 /// The maximum channel dust limit we will accept from our counterparty.
796 pub const MAX_CHAN_DUST_LIMIT_SATOSHIS: u64 = MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS;
797
798 /// The dust limit is used for both the commitment transaction outputs as well as the closing
799 /// transactions. For cooperative closing transactions, we require segwit outputs, though accept
800 /// *any* segwit scripts, which are allowed to be up to 42 bytes in length.
801 /// In order to avoid having to concern ourselves with standardness during the closing process, we
802 /// simply require our counterparty to use a dust limit which will leave any segwit output
803 /// standard.
804 /// See <https://github.com/lightning/bolts/issues/905> for more details.
805 pub const MIN_CHAN_DUST_LIMIT_SATOSHIS: u64 = 354;
806
807 // Just a reasonable implementation-specific safe lower bound, higher than the dust limit.
808 pub const MIN_THEIR_CHAN_RESERVE_SATOSHIS: u64 = 1000;
809
810 /// Used to return a simple Error back to ChannelManager. Will get converted to a
811 /// msgs::ErrorAction::SendErrorMessage or msgs::ErrorAction::IgnoreError as appropriate with our
812 /// channel_id in ChannelManager.
813 pub(super) enum ChannelError {
814         Ignore(String),
815         Warn(String),
816         Close(String),
817 }
818
819 impl fmt::Debug for ChannelError {
820         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
821                 match self {
822                         &ChannelError::Ignore(ref e) => write!(f, "Ignore : {}", e),
823                         &ChannelError::Warn(ref e) => write!(f, "Warn : {}", e),
824                         &ChannelError::Close(ref e) => write!(f, "Close : {}", e),
825                 }
826         }
827 }
828
829 macro_rules! secp_check {
830         ($res: expr, $err: expr) => {
831                 match $res {
832                         Ok(thing) => thing,
833                         Err(_) => return Err(ChannelError::Close($err)),
834                 }
835         };
836 }
837
838 impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
839         /// Returns the value to use for `holder_max_htlc_value_in_flight_msat` as a percentage of the
840         /// `channel_value_satoshis` in msat, set through
841         /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]
842         ///
843         /// The effective percentage is lower bounded by 1% and upper bounded by 100%.
844         ///
845         /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]: crate::util::config::ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel
846         fn get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis: u64, config: &ChannelHandshakeConfig) -> u64 {
847                 let configured_percent = if config.max_inbound_htlc_value_in_flight_percent_of_channel < 1 {
848                         1
849                 } else if config.max_inbound_htlc_value_in_flight_percent_of_channel > 100 {
850                         100
851                 } else {
852                         config.max_inbound_htlc_value_in_flight_percent_of_channel as u64
853                 };
854                 channel_value_satoshis * 10 * configured_percent
855         }
856
857         /// Returns a minimum channel reserve value the remote needs to maintain,
858         /// required by us according to the configured or default
859         /// [`ChannelHandshakeConfig::their_channel_reserve_proportional_millionths`]
860         ///
861         /// Guaranteed to return a value no larger than channel_value_satoshis
862         ///
863         /// This is used both for outbound and inbound channels and has lower bound
864         /// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`.
865         pub(crate) fn get_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64, config: &UserConfig) -> u64 {
866                 let calculated_reserve = channel_value_satoshis.saturating_mul(config.channel_handshake_config.their_channel_reserve_proportional_millionths as u64) / 1_000_000;
867                 cmp::min(channel_value_satoshis, cmp::max(calculated_reserve, MIN_THEIR_CHAN_RESERVE_SATOSHIS))
868         }
869
870         /// This is for legacy reasons, present for forward-compatibility.
871         /// LDK versions older than 0.0.104 don't know how read/handle values other than default
872         /// from storage. Hence, we use this function to not persist default values of
873         /// `holder_selected_channel_reserve_satoshis` for channels into storage.
874         pub(crate) fn get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64) -> u64 {
875                 let (q, _) = channel_value_satoshis.overflowing_div(100);
876                 cmp::min(channel_value_satoshis, cmp::max(q, 1000))
877         }
878
879         pub(crate) fn opt_anchors(&self) -> bool {
880                 self.channel_transaction_parameters.opt_anchors.is_some()
881         }
882
883         fn get_initial_channel_type(config: &UserConfig, their_features: &InitFeatures) -> ChannelTypeFeatures {
884                 // The default channel type (ie the first one we try) depends on whether the channel is
885                 // public - if it is, we just go with `only_static_remotekey` as it's the only option
886                 // available. If it's private, we first try `scid_privacy` as it provides better privacy
887                 // with no other changes, and fall back to `only_static_remotekey`.
888                 let mut ret = ChannelTypeFeatures::only_static_remote_key();
889                 if !config.channel_handshake_config.announced_channel &&
890                         config.channel_handshake_config.negotiate_scid_privacy &&
891                         their_features.supports_scid_privacy() {
892                         ret.set_scid_privacy_required();
893                 }
894
895                 // Optionally, if the user would like to negotiate the `anchors_zero_fee_htlc_tx` option, we
896                 // set it now. If they don't understand it, we'll fall back to our default of
897                 // `only_static_remotekey`.
898                 #[cfg(anchors)]
899                 { // Attributes are not allowed on if expressions on our current MSRV of 1.41.
900                         if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
901                                 their_features.supports_anchors_zero_fee_htlc_tx() {
902                                 ret.set_anchors_zero_fee_htlc_tx_required();
903                         }
904                 }
905
906                 ret
907         }
908
909         /// If we receive an error message, it may only be a rejection of the channel type we tried,
910         /// not of our ability to open any channel at all. Thus, on error, we should first call this
911         /// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
912         pub(crate) fn maybe_handle_error_without_close(&mut self, chain_hash: BlockHash) -> Result<msgs::OpenChannel, ()> {
913                 if !self.is_outbound() || self.channel_state != ChannelState::OurInitSent as u32 { return Err(()); }
914                 if self.channel_type == ChannelTypeFeatures::only_static_remote_key() {
915                         // We've exhausted our options
916                         return Err(());
917                 }
918                 // We support opening a few different types of channels. Try removing our additional
919                 // features one by one until we've either arrived at our default or the counterparty has
920                 // accepted one.
921                 //
922                 // Due to the order below, we may not negotiate `option_anchors_zero_fee_htlc_tx` if the
923                 // counterparty doesn't support `option_scid_privacy`. Since `get_initial_channel_type`
924                 // checks whether the counterparty supports every feature, this would only happen if the
925                 // counterparty is advertising the feature, but rejecting channels proposing the feature for
926                 // whatever reason.
927                 if self.channel_type.supports_anchors_zero_fee_htlc_tx() {
928                         self.channel_type.clear_anchors_zero_fee_htlc_tx();
929                         assert!(self.channel_transaction_parameters.opt_non_zero_fee_anchors.is_none());
930                         self.channel_transaction_parameters.opt_anchors = None;
931                 } else if self.channel_type.supports_scid_privacy() {
932                         self.channel_type.clear_scid_privacy();
933                 } else {
934                         self.channel_type = ChannelTypeFeatures::only_static_remote_key();
935                 }
936                 Ok(self.get_open_channel(chain_hash))
937         }
938
939         // Constructors:
940         pub fn new_outbound<ES: Deref, SP: Deref, F: Deref>(
941                 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, counterparty_node_id: PublicKey, their_features: &InitFeatures,
942                 channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig, current_chain_height: u32,
943                 outbound_scid_alias: u64
944         ) -> Result<Channel<Signer>, APIError>
945         where ES::Target: EntropySource,
946               SP::Target: SignerProvider<Signer = Signer>,
947               F::Target: FeeEstimator,
948         {
949                 let holder_selected_contest_delay = config.channel_handshake_config.our_to_self_delay;
950                 let channel_keys_id = signer_provider.generate_channel_keys_id(false, channel_value_satoshis, user_id);
951                 let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
952                 let pubkeys = holder_signer.pubkeys().clone();
953
954                 if !their_features.supports_wumbo() && channel_value_satoshis > MAX_FUNDING_SATOSHIS_NO_WUMBO {
955                         return Err(APIError::APIMisuseError{err: format!("funding_value must not exceed {}, it was {}", MAX_FUNDING_SATOSHIS_NO_WUMBO, channel_value_satoshis)});
956                 }
957                 if channel_value_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
958                         return Err(APIError::APIMisuseError{err: format!("funding_value must be smaller than the total bitcoin supply, it was {}", channel_value_satoshis)});
959                 }
960                 let channel_value_msat = channel_value_satoshis * 1000;
961                 if push_msat > channel_value_msat {
962                         return Err(APIError::APIMisuseError { err: format!("Push value ({}) was larger than channel_value ({})", push_msat, channel_value_msat) });
963                 }
964                 if holder_selected_contest_delay < BREAKDOWN_TIMEOUT {
965                         return Err(APIError::APIMisuseError {err: format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks", holder_selected_contest_delay)});
966                 }
967                 let holder_selected_channel_reserve_satoshis = Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(channel_value_satoshis, config);
968                 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
969                         // Protocol level safety check in place, although it should never happen because
970                         // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
971                         return Err(APIError::APIMisuseError { err: format!("Holder selected channel  reserve below implemention limit dust_limit_satoshis {}", holder_selected_channel_reserve_satoshis) });
972                 }
973
974                 let channel_type = Self::get_initial_channel_type(&config, their_features);
975                 debug_assert!(channel_type.is_subset(&channelmanager::provided_channel_type_features(&config)));
976
977                 let feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Normal);
978
979                 let value_to_self_msat = channel_value_satoshis * 1000 - push_msat;
980                 let commitment_tx_fee = Self::commit_tx_fee_msat(feerate, MIN_AFFORDABLE_HTLC_COUNT, channel_type.requires_anchors_zero_fee_htlc_tx());
981                 if value_to_self_msat < commitment_tx_fee {
982                         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) });
983                 }
984
985                 let mut secp_ctx = Secp256k1::new();
986                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
987
988                 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
989                         Some(signer_provider.get_shutdown_scriptpubkey())
990                 } else { None };
991
992                 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
993                         if !shutdown_scriptpubkey.is_compatible(&their_features) {
994                                 return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
995                         }
996                 }
997
998                 let temporary_channel_id = entropy_source.get_secure_random_bytes();
999
1000                 Ok(Channel {
1001                         user_id,
1002
1003                         config: LegacyChannelConfig {
1004                                 options: config.channel_config.clone(),
1005                                 announced_channel: config.channel_handshake_config.announced_channel,
1006                                 commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
1007                         },
1008
1009                         prev_config: None,
1010
1011                         inbound_handshake_limits_override: Some(config.channel_handshake_limits.clone()),
1012
1013                         channel_id: temporary_channel_id,
1014                         temporary_channel_id: Some(temporary_channel_id),
1015                         channel_state: ChannelState::OurInitSent as u32,
1016                         announcement_sigs_state: AnnouncementSigsState::NotSent,
1017                         secp_ctx,
1018                         channel_value_satoshis,
1019
1020                         latest_monitor_update_id: 0,
1021
1022                         holder_signer,
1023                         shutdown_scriptpubkey,
1024                         destination_script: signer_provider.get_destination_script(),
1025
1026                         cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
1027                         cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
1028                         value_to_self_msat,
1029
1030                         pending_inbound_htlcs: Vec::new(),
1031                         pending_outbound_htlcs: Vec::new(),
1032                         holding_cell_htlc_updates: Vec::new(),
1033                         pending_update_fee: None,
1034                         holding_cell_update_fee: None,
1035                         next_holder_htlc_id: 0,
1036                         next_counterparty_htlc_id: 0,
1037                         update_time_counter: 1,
1038
1039                         resend_order: RAACommitmentOrder::CommitmentFirst,
1040
1041                         monitor_pending_channel_ready: false,
1042                         monitor_pending_revoke_and_ack: false,
1043                         monitor_pending_commitment_signed: false,
1044                         monitor_pending_forwards: Vec::new(),
1045                         monitor_pending_failures: Vec::new(),
1046                         monitor_pending_finalized_fulfills: Vec::new(),
1047
1048                         #[cfg(debug_assertions)]
1049                         holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
1050                         #[cfg(debug_assertions)]
1051                         counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
1052
1053                         last_sent_closing_fee: None,
1054                         pending_counterparty_closing_signed: None,
1055                         closing_fee_limits: None,
1056                         target_closing_feerate_sats_per_kw: None,
1057
1058                         inbound_awaiting_accept: false,
1059
1060                         funding_tx_confirmed_in: None,
1061                         funding_tx_confirmation_height: 0,
1062                         short_channel_id: None,
1063                         channel_creation_height: current_chain_height,
1064
1065                         feerate_per_kw: feerate,
1066                         counterparty_dust_limit_satoshis: 0,
1067                         holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
1068                         counterparty_max_htlc_value_in_flight_msat: 0,
1069                         holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &config.channel_handshake_config),
1070                         counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
1071                         holder_selected_channel_reserve_satoshis,
1072                         counterparty_htlc_minimum_msat: 0,
1073                         holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
1074                         counterparty_max_accepted_htlcs: 0,
1075                         minimum_depth: None, // Filled in in accept_channel
1076
1077                         counterparty_forwarding_info: None,
1078
1079                         channel_transaction_parameters: ChannelTransactionParameters {
1080                                 holder_pubkeys: pubkeys,
1081                                 holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
1082                                 is_outbound_from_holder: true,
1083                                 counterparty_parameters: None,
1084                                 funding_outpoint: None,
1085                                 opt_anchors: if channel_type.requires_anchors_zero_fee_htlc_tx() { Some(()) } else { None },
1086                                 opt_non_zero_fee_anchors: None
1087                         },
1088                         funding_transaction: None,
1089
1090                         counterparty_cur_commitment_point: None,
1091                         counterparty_prev_commitment_point: None,
1092                         counterparty_node_id,
1093
1094                         counterparty_shutdown_scriptpubkey: None,
1095
1096                         commitment_secrets: CounterpartyCommitmentSecrets::new(),
1097
1098                         channel_update_status: ChannelUpdateStatus::Enabled,
1099                         closing_signed_in_flight: false,
1100
1101                         announcement_sigs: None,
1102
1103                         #[cfg(any(test, fuzzing))]
1104                         next_local_commitment_tx_fee_info_cached: Mutex::new(None),
1105                         #[cfg(any(test, fuzzing))]
1106                         next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
1107
1108                         workaround_lnd_bug_4006: None,
1109
1110                         latest_inbound_scid_alias: None,
1111                         outbound_scid_alias,
1112
1113                         channel_pending_event_emitted: false,
1114                         channel_ready_event_emitted: false,
1115
1116                         #[cfg(any(test, fuzzing))]
1117                         historical_inbound_htlc_fulfills: HashSet::new(),
1118
1119                         channel_type,
1120                         channel_keys_id,
1121
1122                         pending_monitor_updates: Vec::new(),
1123                 })
1124         }
1125
1126         fn check_remote_fee<F: Deref, L: Deref>(fee_estimator: &LowerBoundedFeeEstimator<F>,
1127                 feerate_per_kw: u32, cur_feerate_per_kw: Option<u32>, logger: &L)
1128                 -> Result<(), ChannelError> where F::Target: FeeEstimator, L::Target: Logger,
1129         {
1130                 // We only bound the fee updates on the upper side to prevent completely absurd feerates,
1131                 // always accepting up to 25 sat/vByte or 10x our fee estimator's "High Priority" fee.
1132                 // We generally don't care too much if they set the feerate to something very high, but it
1133                 // could result in the channel being useless due to everything being dust.
1134                 let upper_limit = cmp::max(250 * 25,
1135                         fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::HighPriority) as u64 * 10);
1136                 if feerate_per_kw as u64 > upper_limit {
1137                         return Err(ChannelError::Close(format!("Peer's feerate much too high. Actual: {}. Our expected upper limit: {}", feerate_per_kw, upper_limit)));
1138                 }
1139                 let lower_limit = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Background);
1140                 // Some fee estimators round up to the next full sat/vbyte (ie 250 sats per kw), causing
1141                 // occasional issues with feerate disagreements between an initiator that wants a feerate
1142                 // of 1.1 sat/vbyte and a receiver that wants 1.1 rounded up to 2. Thus, we always add 250
1143                 // sat/kw before the comparison here.
1144                 if feerate_per_kw + 250 < lower_limit {
1145                         if let Some(cur_feerate) = cur_feerate_per_kw {
1146                                 if feerate_per_kw > cur_feerate {
1147                                         log_warn!(logger,
1148                                                 "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.",
1149                                                 cur_feerate, feerate_per_kw);
1150                                         return Ok(());
1151                                 }
1152                         }
1153                         return Err(ChannelError::Close(format!("Peer's feerate much too low. Actual: {}. Our expected lower limit: {} (- 250)", feerate_per_kw, lower_limit)));
1154                 }
1155                 Ok(())
1156         }
1157
1158         /// Creates a new channel from a remote sides' request for one.
1159         /// Assumes chain_hash has already been checked and corresponds with what we expect!
1160         pub fn new_from_req<ES: Deref, SP: Deref, F: Deref, L: Deref>(
1161                 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
1162                 counterparty_node_id: PublicKey, our_supported_features: &ChannelTypeFeatures,
1163                 their_features: &InitFeatures, msg: &msgs::OpenChannel, user_id: u128, config: &UserConfig,
1164                 current_chain_height: u32, logger: &L, outbound_scid_alias: u64
1165         ) -> Result<Channel<Signer>, ChannelError>
1166                 where ES::Target: EntropySource,
1167                           SP::Target: SignerProvider<Signer = Signer>,
1168                           F::Target: FeeEstimator,
1169                           L::Target: Logger,
1170         {
1171                 let announced_channel = if (msg.channel_flags & 1) == 1 { true } else { false };
1172
1173                 // First check the channel type is known, failing before we do anything else if we don't
1174                 // support this channel type.
1175                 let channel_type = if let Some(channel_type) = &msg.channel_type {
1176                         if channel_type.supports_any_optional_bits() {
1177                                 return Err(ChannelError::Close("Channel Type field contained optional bits - this is not allowed".to_owned()));
1178                         }
1179
1180                         // We only support the channel types defined by the `ChannelManager` in
1181                         // `provided_channel_type_features`. The channel type must always support
1182                         // `static_remote_key`.
1183                         if !channel_type.requires_static_remote_key() {
1184                                 return Err(ChannelError::Close("Channel Type was not understood - we require static remote key".to_owned()));
1185                         }
1186                         // Make sure we support all of the features behind the channel type.
1187                         if !channel_type.is_subset(our_supported_features) {
1188                                 return Err(ChannelError::Close("Channel Type contains unsupported features".to_owned()));
1189                         }
1190                         if channel_type.requires_scid_privacy() && announced_channel {
1191                                 return Err(ChannelError::Close("SCID Alias/Privacy Channel Type cannot be set on a public channel".to_owned()));
1192                         }
1193                         channel_type.clone()
1194                 } else {
1195                         let channel_type = ChannelTypeFeatures::from_init(&their_features);
1196                         if channel_type != ChannelTypeFeatures::only_static_remote_key() {
1197                                 return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
1198                         }
1199                         channel_type
1200                 };
1201                 let opt_anchors = channel_type.supports_anchors_zero_fee_htlc_tx();
1202
1203                 let channel_keys_id = signer_provider.generate_channel_keys_id(true, msg.funding_satoshis, user_id);
1204                 let holder_signer = signer_provider.derive_channel_signer(msg.funding_satoshis, channel_keys_id);
1205                 let pubkeys = holder_signer.pubkeys().clone();
1206                 let counterparty_pubkeys = ChannelPublicKeys {
1207                         funding_pubkey: msg.funding_pubkey,
1208                         revocation_basepoint: msg.revocation_basepoint,
1209                         payment_point: msg.payment_point,
1210                         delayed_payment_basepoint: msg.delayed_payment_basepoint,
1211                         htlc_basepoint: msg.htlc_basepoint
1212                 };
1213
1214                 if config.channel_handshake_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
1215                         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)));
1216                 }
1217
1218                 // Check sanity of message fields:
1219                 if msg.funding_satoshis > config.channel_handshake_limits.max_funding_satoshis {
1220                         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)));
1221                 }
1222                 if msg.funding_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
1223                         return Err(ChannelError::Close(format!("Funding must be smaller than the total bitcoin supply. It was {}", msg.funding_satoshis)));
1224                 }
1225                 if msg.channel_reserve_satoshis > msg.funding_satoshis {
1226                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must be not greater than funding_satoshis: {}", msg.channel_reserve_satoshis, msg.funding_satoshis)));
1227                 }
1228                 let full_channel_value_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000;
1229                 if msg.push_msat > full_channel_value_msat {
1230                         return Err(ChannelError::Close(format!("push_msat {} was larger than channel amount minus reserve ({})", msg.push_msat, full_channel_value_msat)));
1231                 }
1232                 if msg.dust_limit_satoshis > msg.funding_satoshis {
1233                         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)));
1234                 }
1235                 if msg.htlc_minimum_msat >= full_channel_value_msat {
1236                         return Err(ChannelError::Close(format!("Minimum htlc value ({}) was larger than full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
1237                 }
1238                 Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, None, logger)?;
1239
1240                 let max_counterparty_selected_contest_delay = u16::min(config.channel_handshake_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
1241                 if msg.to_self_delay > max_counterparty_selected_contest_delay {
1242                         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)));
1243                 }
1244                 if msg.max_accepted_htlcs < 1 {
1245                         return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
1246                 }
1247                 if msg.max_accepted_htlcs > MAX_HTLCS {
1248                         return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
1249                 }
1250
1251                 // Now check against optional parameters as set by config...
1252                 if msg.funding_satoshis < config.channel_handshake_limits.min_funding_satoshis {
1253                         return Err(ChannelError::Close(format!("Funding satoshis ({}) is less than the user specified limit ({})", msg.funding_satoshis, config.channel_handshake_limits.min_funding_satoshis)));
1254                 }
1255                 if msg.htlc_minimum_msat > config.channel_handshake_limits.max_htlc_minimum_msat {
1256                         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)));
1257                 }
1258                 if msg.max_htlc_value_in_flight_msat < config.channel_handshake_limits.min_max_htlc_value_in_flight_msat {
1259                         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)));
1260                 }
1261                 if msg.channel_reserve_satoshis > config.channel_handshake_limits.max_channel_reserve_satoshis {
1262                         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)));
1263                 }
1264                 if msg.max_accepted_htlcs < config.channel_handshake_limits.min_max_accepted_htlcs {
1265                         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)));
1266                 }
1267                 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
1268                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
1269                 }
1270                 if msg.dust_limit_satoshis >  MAX_CHAN_DUST_LIMIT_SATOSHIS {
1271                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
1272                 }
1273
1274                 // Convert things into internal flags and prep our state:
1275
1276                 if config.channel_handshake_limits.force_announced_channel_preference {
1277                         if config.channel_handshake_config.announced_channel != announced_channel {
1278                                 return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours".to_owned()));
1279                         }
1280                 }
1281
1282                 let holder_selected_channel_reserve_satoshis = Channel::<Signer>::get_holder_selected_channel_reserve_satoshis(msg.funding_satoshis, config);
1283                 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
1284                         // Protocol level safety check in place, although it should never happen because
1285                         // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
1286                         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)));
1287                 }
1288                 if holder_selected_channel_reserve_satoshis * 1000 >= full_channel_value_msat {
1289                         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)));
1290                 }
1291                 if msg.channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
1292                         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.",
1293                                 msg.channel_reserve_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS);
1294                 }
1295                 if holder_selected_channel_reserve_satoshis < msg.dust_limit_satoshis {
1296                         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)));
1297                 }
1298
1299                 // check if the funder's amount for the initial commitment tx is sufficient
1300                 // for full fee payment plus a few HTLCs to ensure the channel will be useful.
1301                 let funders_amount_msat = msg.funding_satoshis * 1000 - msg.push_msat;
1302                 let commitment_tx_fee = Self::commit_tx_fee_msat(msg.feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT, opt_anchors) / 1000;
1303                 if funders_amount_msat / 1000 < commitment_tx_fee {
1304                         return Err(ChannelError::Close(format!("Funding amount ({} sats) can't even pay fee for initial commitment transaction fee of {} sats.", funders_amount_msat / 1000, commitment_tx_fee)));
1305                 }
1306
1307                 let to_remote_satoshis = funders_amount_msat / 1000 - commitment_tx_fee;
1308                 // While it's reasonable for us to not meet the channel reserve initially (if they don't
1309                 // want to push much to us), our counterparty should always have more than our reserve.
1310                 if to_remote_satoshis < holder_selected_channel_reserve_satoshis {
1311                         return Err(ChannelError::Close("Insufficient funding amount for initial reserve".to_owned()));
1312                 }
1313
1314                 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
1315                         match &msg.shutdown_scriptpubkey {
1316                                 &OptionalField::Present(ref script) => {
1317                                         // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
1318                                         if script.len() == 0 {
1319                                                 None
1320                                         } else {
1321                                                 if !script::is_bolt2_compliant(&script, their_features) {
1322                                                         return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)))
1323                                                 }
1324                                                 Some(script.clone())
1325                                         }
1326                                 },
1327                                 // 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
1328                                 &OptionalField::Absent => {
1329                                         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()));
1330                                 }
1331                         }
1332                 } else { None };
1333
1334                 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
1335                         Some(signer_provider.get_shutdown_scriptpubkey())
1336                 } else { None };
1337
1338                 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
1339                         if !shutdown_scriptpubkey.is_compatible(&their_features) {
1340                                 return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
1341                         }
1342                 }
1343
1344                 let mut secp_ctx = Secp256k1::new();
1345                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
1346
1347                 let chan = Channel {
1348                         user_id,
1349
1350                         config: LegacyChannelConfig {
1351                                 options: config.channel_config.clone(),
1352                                 announced_channel,
1353                                 commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
1354                         },
1355
1356                         prev_config: None,
1357
1358                         inbound_handshake_limits_override: None,
1359
1360                         channel_id: msg.temporary_channel_id,
1361                         temporary_channel_id: Some(msg.temporary_channel_id),
1362                         channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
1363                         announcement_sigs_state: AnnouncementSigsState::NotSent,
1364                         secp_ctx,
1365
1366                         latest_monitor_update_id: 0,
1367
1368                         holder_signer,
1369                         shutdown_scriptpubkey,
1370                         destination_script: signer_provider.get_destination_script(),
1371
1372                         cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
1373                         cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
1374                         value_to_self_msat: msg.push_msat,
1375
1376                         pending_inbound_htlcs: Vec::new(),
1377                         pending_outbound_htlcs: Vec::new(),
1378                         holding_cell_htlc_updates: Vec::new(),
1379                         pending_update_fee: None,
1380                         holding_cell_update_fee: None,
1381                         next_holder_htlc_id: 0,
1382                         next_counterparty_htlc_id: 0,
1383                         update_time_counter: 1,
1384
1385                         resend_order: RAACommitmentOrder::CommitmentFirst,
1386
1387                         monitor_pending_channel_ready: false,
1388                         monitor_pending_revoke_and_ack: false,
1389                         monitor_pending_commitment_signed: false,
1390                         monitor_pending_forwards: Vec::new(),
1391                         monitor_pending_failures: Vec::new(),
1392                         monitor_pending_finalized_fulfills: Vec::new(),
1393
1394                         #[cfg(debug_assertions)]
1395                         holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
1396                         #[cfg(debug_assertions)]
1397                         counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
1398
1399                         last_sent_closing_fee: None,
1400                         pending_counterparty_closing_signed: None,
1401                         closing_fee_limits: None,
1402                         target_closing_feerate_sats_per_kw: None,
1403
1404                         inbound_awaiting_accept: true,
1405
1406                         funding_tx_confirmed_in: None,
1407                         funding_tx_confirmation_height: 0,
1408                         short_channel_id: None,
1409                         channel_creation_height: current_chain_height,
1410
1411                         feerate_per_kw: msg.feerate_per_kw,
1412                         channel_value_satoshis: msg.funding_satoshis,
1413                         counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
1414                         holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
1415                         counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
1416                         holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(msg.funding_satoshis, &config.channel_handshake_config),
1417                         counterparty_selected_channel_reserve_satoshis: Some(msg.channel_reserve_satoshis),
1418                         holder_selected_channel_reserve_satoshis,
1419                         counterparty_htlc_minimum_msat: msg.htlc_minimum_msat,
1420                         holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
1421                         counterparty_max_accepted_htlcs: msg.max_accepted_htlcs,
1422                         minimum_depth: Some(cmp::max(config.channel_handshake_config.minimum_depth, 1)),
1423
1424                         counterparty_forwarding_info: None,
1425
1426                         channel_transaction_parameters: ChannelTransactionParameters {
1427                                 holder_pubkeys: pubkeys,
1428                                 holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
1429                                 is_outbound_from_holder: false,
1430                                 counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
1431                                         selected_contest_delay: msg.to_self_delay,
1432                                         pubkeys: counterparty_pubkeys,
1433                                 }),
1434                                 funding_outpoint: None,
1435                                 opt_anchors: if opt_anchors { Some(()) } else { None },
1436                                 opt_non_zero_fee_anchors: None
1437                         },
1438                         funding_transaction: None,
1439
1440                         counterparty_cur_commitment_point: Some(msg.first_per_commitment_point),
1441                         counterparty_prev_commitment_point: None,
1442                         counterparty_node_id,
1443
1444                         counterparty_shutdown_scriptpubkey,
1445
1446                         commitment_secrets: CounterpartyCommitmentSecrets::new(),
1447
1448                         channel_update_status: ChannelUpdateStatus::Enabled,
1449                         closing_signed_in_flight: false,
1450
1451                         announcement_sigs: None,
1452
1453                         #[cfg(any(test, fuzzing))]
1454                         next_local_commitment_tx_fee_info_cached: Mutex::new(None),
1455                         #[cfg(any(test, fuzzing))]
1456                         next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
1457
1458                         workaround_lnd_bug_4006: None,
1459
1460                         latest_inbound_scid_alias: None,
1461                         outbound_scid_alias,
1462
1463                         channel_pending_event_emitted: false,
1464                         channel_ready_event_emitted: false,
1465
1466                         #[cfg(any(test, fuzzing))]
1467                         historical_inbound_htlc_fulfills: HashSet::new(),
1468
1469                         channel_type,
1470                         channel_keys_id,
1471
1472                         pending_monitor_updates: Vec::new(),
1473                 };
1474
1475                 Ok(chan)
1476         }
1477
1478         /// Transaction nomenclature is somewhat confusing here as there are many different cases - a
1479         /// transaction is referred to as "a's transaction" implying that a will be able to broadcast
1480         /// the transaction. Thus, b will generally be sending a signature over such a transaction to
1481         /// a, and a can revoke the transaction by providing b the relevant per_commitment_secret. As
1482         /// such, a transaction is generally the result of b increasing the amount paid to a (or adding
1483         /// an HTLC to a).
1484         /// @local is used only to convert relevant internal structures which refer to remote vs local
1485         /// to decide value of outputs and direction of HTLCs.
1486         /// @generated_by_local is used to determine *which* HTLCs to include - noting that the HTLC
1487         /// state may indicate that one peer has informed the other that they'd like to add an HTLC but
1488         /// have not yet committed it. Such HTLCs will only be included in transactions which are being
1489         /// generated by the peer which proposed adding the HTLCs, and thus we need to understand both
1490         /// which peer generated this transaction and "to whom" this transaction flows.
1491         #[inline]
1492         fn build_commitment_transaction<L: Deref>(&self, commitment_number: u64, keys: &TxCreationKeys, local: bool, generated_by_local: bool, logger: &L) -> CommitmentStats
1493                 where L::Target: Logger
1494         {
1495                 let mut included_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::new();
1496                 let num_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
1497                 let mut included_non_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
1498
1499                 let broadcaster_dust_limit_satoshis = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
1500                 let mut remote_htlc_total_msat = 0;
1501                 let mut local_htlc_total_msat = 0;
1502                 let mut value_to_self_msat_offset = 0;
1503
1504                 let mut feerate_per_kw = self.feerate_per_kw;
1505                 if let Some((feerate, update_state)) = self.pending_update_fee {
1506                         if match update_state {
1507                                 // Note that these match the inclusion criteria when scanning
1508                                 // pending_inbound_htlcs below.
1509                                 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.is_outbound()); !generated_by_local },
1510                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => { debug_assert!(!self.is_outbound()); !generated_by_local },
1511                                 FeeUpdateState::Outbound => { assert!(self.is_outbound());  generated_by_local },
1512                         } {
1513                                 feerate_per_kw = feerate;
1514                         }
1515                 }
1516
1517                 log_trace!(logger, "Building commitment transaction number {} (really {} xor {}) for channel {} for {}, generated by {} with fee {}...",
1518                         commitment_number, (INITIAL_COMMITMENT_NUMBER - commitment_number),
1519                         get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()),
1520                         log_bytes!(self.channel_id), if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);
1521
1522                 macro_rules! get_htlc_in_commitment {
1523                         ($htlc: expr, $offered: expr) => {
1524                                 HTLCOutputInCommitment {
1525                                         offered: $offered,
1526                                         amount_msat: $htlc.amount_msat,
1527                                         cltv_expiry: $htlc.cltv_expiry,
1528                                         payment_hash: $htlc.payment_hash,
1529                                         transaction_output_index: None
1530                                 }
1531                         }
1532                 }
1533
1534                 macro_rules! add_htlc_output {
1535                         ($htlc: expr, $outbound: expr, $source: expr, $state_name: expr) => {
1536                                 if $outbound == local { // "offered HTLC output"
1537                                         let htlc_in_tx = get_htlc_in_commitment!($htlc, true);
1538                                         let htlc_tx_fee = if self.opt_anchors() {
1539                                                 0
1540                                         } else {
1541                                                 feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000
1542                                         };
1543                                         if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1544                                                 log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1545                                                 included_non_dust_htlcs.push((htlc_in_tx, $source));
1546                                         } else {
1547                                                 log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {} due to dust limit", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1548                                                 included_dust_htlcs.push((htlc_in_tx, $source));
1549                                         }
1550                                 } else {
1551                                         let htlc_in_tx = get_htlc_in_commitment!($htlc, false);
1552                                         let htlc_tx_fee = if self.opt_anchors() {
1553                                                 0
1554                                         } else {
1555                                                 feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000
1556                                         };
1557                                         if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1558                                                 log_trace!(logger, "   ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1559                                                 included_non_dust_htlcs.push((htlc_in_tx, $source));
1560                                         } else {
1561                                                 log_trace!(logger, "   ...including {} {} dust HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1562                                                 included_dust_htlcs.push((htlc_in_tx, $source));
1563                                         }
1564                                 }
1565                         }
1566                 }
1567
1568                 for ref htlc in self.pending_inbound_htlcs.iter() {
1569                         let (include, state_name) = match htlc.state {
1570                                 InboundHTLCState::RemoteAnnounced(_) => (!generated_by_local, "RemoteAnnounced"),
1571                                 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => (!generated_by_local, "AwaitingRemoteRevokeToAnnounce"),
1572                                 InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => (true, "AwaitingAnnouncedRemoteRevoke"),
1573                                 InboundHTLCState::Committed => (true, "Committed"),
1574                                 InboundHTLCState::LocalRemoved(_) => (!generated_by_local, "LocalRemoved"),
1575                         };
1576
1577                         if include {
1578                                 add_htlc_output!(htlc, false, None, state_name);
1579                                 remote_htlc_total_msat += htlc.amount_msat;
1580                         } else {
1581                                 log_trace!(logger, "   ...not including inbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, log_bytes!(htlc.payment_hash.0), htlc.amount_msat, state_name);
1582                                 match &htlc.state {
1583                                         &InboundHTLCState::LocalRemoved(ref reason) => {
1584                                                 if generated_by_local {
1585                                                         if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
1586                                                                 value_to_self_msat_offset += htlc.amount_msat as i64;
1587                                                         }
1588                                                 }
1589                                         },
1590                                         _ => {},
1591                                 }
1592                         }
1593                 }
1594
1595                 let mut preimages: Vec<PaymentPreimage> = Vec::new();
1596
1597                 for ref htlc in self.pending_outbound_htlcs.iter() {
1598                         let (include, state_name) = match htlc.state {
1599                                 OutboundHTLCState::LocalAnnounced(_) => (generated_by_local, "LocalAnnounced"),
1600                                 OutboundHTLCState::Committed => (true, "Committed"),
1601                                 OutboundHTLCState::RemoteRemoved(_) => (generated_by_local, "RemoteRemoved"),
1602                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) => (generated_by_local, "AwaitingRemoteRevokeToRemove"),
1603                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => (false, "AwaitingRemovedRemoteRevoke"),
1604                         };
1605
1606                         let preimage_opt = match htlc.state {
1607                                 OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(p)) => p,
1608                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(p)) => p,
1609                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(p)) => p,
1610                                 _ => None,
1611                         };
1612
1613                         if let Some(preimage) = preimage_opt {
1614                                 preimages.push(preimage);
1615                         }
1616
1617                         if include {
1618                                 add_htlc_output!(htlc, true, Some(&htlc.source), state_name);
1619                                 local_htlc_total_msat += htlc.amount_msat;
1620                         } else {
1621                                 log_trace!(logger, "   ...not including outbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, log_bytes!(htlc.payment_hash.0), htlc.amount_msat, state_name);
1622                                 match htlc.state {
1623                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_))|OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) => {
1624                                                 value_to_self_msat_offset -= htlc.amount_msat as i64;
1625                                         },
1626                                         OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(_)) => {
1627                                                 if !generated_by_local {
1628                                                         value_to_self_msat_offset -= htlc.amount_msat as i64;
1629                                                 }
1630                                         },
1631                                         _ => {},
1632                                 }
1633                         }
1634                 }
1635
1636                 let mut value_to_self_msat: i64 = (self.value_to_self_msat - local_htlc_total_msat) as i64 + value_to_self_msat_offset;
1637                 assert!(value_to_self_msat >= 0);
1638                 // Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
1639                 // AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
1640                 // "violate" their reserve value by couting those against it. Thus, we have to convert
1641                 // everything to i64 before subtracting as otherwise we can overflow.
1642                 let mut 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;
1643                 assert!(value_to_remote_msat >= 0);
1644
1645                 #[cfg(debug_assertions)]
1646                 {
1647                         // Make sure that the to_self/to_remote is always either past the appropriate
1648                         // channel_reserve *or* it is making progress towards it.
1649                         let mut broadcaster_max_commitment_tx_output = if generated_by_local {
1650                                 self.holder_max_commitment_tx_output.lock().unwrap()
1651                         } else {
1652                                 self.counterparty_max_commitment_tx_output.lock().unwrap()
1653                         };
1654                         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);
1655                         broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, value_to_self_msat as u64);
1656                         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);
1657                         broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, value_to_remote_msat as u64);
1658                 }
1659
1660                 let total_fee_sat = Channel::<Signer>::commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), self.channel_transaction_parameters.opt_anchors.is_some());
1661                 let anchors_val = if self.channel_transaction_parameters.opt_anchors.is_some() { ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 } as i64;
1662                 let (value_to_self, value_to_remote) = if self.is_outbound() {
1663                         (value_to_self_msat / 1000 - anchors_val - total_fee_sat as i64, value_to_remote_msat / 1000)
1664                 } else {
1665                         (value_to_self_msat / 1000, value_to_remote_msat / 1000 - anchors_val - total_fee_sat as i64)
1666                 };
1667
1668                 let mut value_to_a = if local { value_to_self } else { value_to_remote };
1669                 let mut value_to_b = if local { value_to_remote } else { value_to_self };
1670                 let (funding_pubkey_a, funding_pubkey_b) = if local {
1671                         (self.get_holder_pubkeys().funding_pubkey, self.get_counterparty_pubkeys().funding_pubkey)
1672                 } else {
1673                         (self.get_counterparty_pubkeys().funding_pubkey, self.get_holder_pubkeys().funding_pubkey)
1674                 };
1675
1676                 if value_to_a >= (broadcaster_dust_limit_satoshis as i64) {
1677                         log_trace!(logger, "   ...including {} output with value {}", if local { "to_local" } else { "to_remote" }, value_to_a);
1678                 } else {
1679                         value_to_a = 0;
1680                 }
1681
1682                 if value_to_b >= (broadcaster_dust_limit_satoshis as i64) {
1683                         log_trace!(logger, "   ...including {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
1684                 } else {
1685                         value_to_b = 0;
1686                 }
1687
1688                 let num_nondust_htlcs = included_non_dust_htlcs.len();
1689
1690                 let channel_parameters =
1691                         if local { self.channel_transaction_parameters.as_holder_broadcastable() }
1692                         else { self.channel_transaction_parameters.as_counterparty_broadcastable() };
1693                 let tx = CommitmentTransaction::new_with_auxiliary_htlc_data(commitment_number,
1694                                                                              value_to_a as u64,
1695                                                                              value_to_b as u64,
1696                                                                              self.channel_transaction_parameters.opt_anchors.is_some(),
1697                                                                              funding_pubkey_a,
1698                                                                              funding_pubkey_b,
1699                                                                              keys.clone(),
1700                                                                              feerate_per_kw,
1701                                                                              &mut included_non_dust_htlcs,
1702                                                                              &channel_parameters
1703                 );
1704                 let mut htlcs_included = included_non_dust_htlcs;
1705                 // The unwrap is safe, because all non-dust HTLCs have been assigned an output index
1706                 htlcs_included.sort_unstable_by_key(|h| h.0.transaction_output_index.unwrap());
1707                 htlcs_included.append(&mut included_dust_htlcs);
1708
1709                 // For the stats, trimmed-to-0 the value in msats accordingly
1710                 value_to_self_msat = if (value_to_self_msat * 1000) < broadcaster_dust_limit_satoshis as i64 { 0 } else { value_to_self_msat };
1711                 value_to_remote_msat = if (value_to_remote_msat * 1000) < broadcaster_dust_limit_satoshis as i64 { 0 } else { value_to_remote_msat };
1712
1713                 CommitmentStats {
1714                         tx,
1715                         feerate_per_kw,
1716                         total_fee_sat,
1717                         num_nondust_htlcs,
1718                         htlcs_included,
1719                         local_balance_msat: value_to_self_msat as u64,
1720                         remote_balance_msat: value_to_remote_msat as u64,
1721                         preimages
1722                 }
1723         }
1724
1725         #[inline]
1726         fn get_closing_scriptpubkey(&self) -> Script {
1727                 // The shutdown scriptpubkey is set on channel opening when option_upfront_shutdown_script
1728                 // is signaled. Otherwise, it is set when sending a shutdown message. Calling this method
1729                 // outside of those situations will fail.
1730                 self.shutdown_scriptpubkey.clone().unwrap().into_inner()
1731         }
1732
1733         #[inline]
1734         fn get_closing_transaction_weight(&self, a_scriptpubkey: Option<&Script>, b_scriptpubkey: Option<&Script>) -> u64 {
1735                 let mut ret =
1736                 (4 +                                           // version
1737                  1 +                                           // input count
1738                  36 +                                          // prevout
1739                  1 +                                           // script length (0)
1740                  4 +                                           // sequence
1741                  1 +                                           // output count
1742                  4                                             // lock time
1743                  )*4 +                                         // * 4 for non-witness parts
1744                 2 +                                            // witness marker and flag
1745                 1 +                                            // witness element count
1746                 4 +                                            // 4 element lengths (2 sigs, multisig dummy, and witness script)
1747                 self.get_funding_redeemscript().len() as u64 + // funding witness script
1748                 2*(1 + 71);                                    // two signatures + sighash type flags
1749                 if let Some(spk) = a_scriptpubkey {
1750                         ret += ((8+1) +                            // output values and script length
1751                                 spk.len() as u64) * 4;                 // scriptpubkey and witness multiplier
1752                 }
1753                 if let Some(spk) = b_scriptpubkey {
1754                         ret += ((8+1) +                            // output values and script length
1755                                 spk.len() as u64) * 4;                 // scriptpubkey and witness multiplier
1756                 }
1757                 ret
1758         }
1759
1760         #[inline]
1761         fn build_closing_transaction(&self, proposed_total_fee_satoshis: u64, skip_remote_output: bool) -> (ClosingTransaction, u64) {
1762                 assert!(self.pending_inbound_htlcs.is_empty());
1763                 assert!(self.pending_outbound_htlcs.is_empty());
1764                 assert!(self.pending_update_fee.is_none());
1765
1766                 let mut total_fee_satoshis = proposed_total_fee_satoshis;
1767                 let mut value_to_holder: i64 = (self.value_to_self_msat as i64) / 1000 - if self.is_outbound() { total_fee_satoshis as i64 } else { 0 };
1768                 let mut value_to_counterparty: i64 = ((self.channel_value_satoshis * 1000 - self.value_to_self_msat) as i64 / 1000) - if self.is_outbound() { 0 } else { total_fee_satoshis as i64 };
1769
1770                 if value_to_holder < 0 {
1771                         assert!(self.is_outbound());
1772                         total_fee_satoshis += (-value_to_holder) as u64;
1773                 } else if value_to_counterparty < 0 {
1774                         assert!(!self.is_outbound());
1775                         total_fee_satoshis += (-value_to_counterparty) as u64;
1776                 }
1777
1778                 if skip_remote_output || value_to_counterparty as u64 <= self.holder_dust_limit_satoshis {
1779                         value_to_counterparty = 0;
1780                 }
1781
1782                 if value_to_holder as u64 <= self.holder_dust_limit_satoshis {
1783                         value_to_holder = 0;
1784                 }
1785
1786                 assert!(self.shutdown_scriptpubkey.is_some());
1787                 let holder_shutdown_script = self.get_closing_scriptpubkey();
1788                 let counterparty_shutdown_script = self.counterparty_shutdown_scriptpubkey.clone().unwrap();
1789                 let funding_outpoint = self.funding_outpoint().into_bitcoin_outpoint();
1790
1791                 let closing_transaction = ClosingTransaction::new(value_to_holder as u64, value_to_counterparty as u64, holder_shutdown_script, counterparty_shutdown_script, funding_outpoint);
1792                 (closing_transaction, total_fee_satoshis)
1793         }
1794
1795         fn funding_outpoint(&self) -> OutPoint {
1796                 self.channel_transaction_parameters.funding_outpoint.unwrap()
1797         }
1798
1799         #[inline]
1800         /// Creates a set of keys for build_commitment_transaction to generate a transaction which our
1801         /// counterparty will sign (ie DO NOT send signatures over a transaction created by this to
1802         /// our counterparty!)
1803         /// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
1804         /// TODO Some magic rust shit to compile-time check this?
1805         fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
1806                 let per_commitment_point = self.holder_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
1807                 let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
1808                 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
1809                 let counterparty_pubkeys = self.get_counterparty_pubkeys();
1810
1811                 TxCreationKeys::derive_new(&self.secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint)
1812         }
1813
1814         #[inline]
1815         /// Creates a set of keys for build_commitment_transaction to generate a transaction which we
1816         /// will sign and send to our counterparty.
1817         /// If an Err is returned, it is a ChannelError::Close (for get_outbound_funding_created)
1818         fn build_remote_transaction_keys(&self) -> TxCreationKeys {
1819                 //TODO: Ensure that the payment_key derived here ends up in the library users' wallet as we
1820                 //may see payments to it!
1821                 let revocation_basepoint = &self.get_holder_pubkeys().revocation_basepoint;
1822                 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
1823                 let counterparty_pubkeys = self.get_counterparty_pubkeys();
1824
1825                 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)
1826         }
1827
1828         /// Gets the redeemscript for the funding transaction output (ie the funding transaction output
1829         /// pays to get_funding_redeemscript().to_v0_p2wsh()).
1830         /// Panics if called before accept_channel/new_from_req
1831         pub fn get_funding_redeemscript(&self) -> Script {
1832                 make_funding_redeemscript(&self.get_holder_pubkeys().funding_pubkey, self.counterparty_funding_pubkey())
1833         }
1834
1835         /// Claims an HTLC while we're disconnected from a peer, dropping the [`ChannelMonitorUpdate`]
1836         /// entirely.
1837         ///
1838         /// The [`ChannelMonitor`] for this channel MUST be updated out-of-band with the preimage
1839         /// provided (i.e. without calling [`crate::chain::Watch::update_channel`]).
1840         ///
1841         /// The HTLC claim will end up in the holding cell (because the caller must ensure the peer is
1842         /// disconnected).
1843         pub fn claim_htlc_while_disconnected_dropping_mon_update<L: Deref>
1844                 (&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L)
1845         where L::Target: Logger {
1846                 // Assert that we'll add the HTLC claim to the holding cell in `get_update_fulfill_htlc`
1847                 // (see equivalent if condition there).
1848                 assert!(self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0);
1849                 let mon_update_id = self.latest_monitor_update_id; // Forget the ChannelMonitor update
1850                 let fulfill_resp = self.get_update_fulfill_htlc(htlc_id_arg, payment_preimage_arg, logger);
1851                 self.latest_monitor_update_id = mon_update_id;
1852                 if let UpdateFulfillFetch::NewClaim { msg, .. } = fulfill_resp {
1853                         assert!(msg.is_none()); // The HTLC must have ended up in the holding cell.
1854                 }
1855         }
1856
1857         fn get_update_fulfill_htlc<L: Deref>(&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L) -> UpdateFulfillFetch where L::Target: Logger {
1858                 // Either ChannelReady got set (which means it won't be unset) or there is no way any
1859                 // caller thought we could have something claimed (cause we wouldn't have accepted in an
1860                 // incoming HTLC anyway). If we got to ShutdownComplete, callers aren't allowed to call us,
1861                 // either.
1862                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
1863                         panic!("Was asked to fulfill an HTLC when channel was not in an operational state");
1864                 }
1865                 assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
1866
1867                 let payment_hash_calc = PaymentHash(Sha256::hash(&payment_preimage_arg.0[..]).into_inner());
1868
1869                 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
1870                 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
1871                 // these, but for now we just have to treat them as normal.
1872
1873                 let mut pending_idx = core::usize::MAX;
1874                 let mut htlc_value_msat = 0;
1875                 for (idx, htlc) in self.pending_inbound_htlcs.iter().enumerate() {
1876                         if htlc.htlc_id == htlc_id_arg {
1877                                 assert_eq!(htlc.payment_hash, payment_hash_calc);
1878                                 match htlc.state {
1879                                         InboundHTLCState::Committed => {},
1880                                         InboundHTLCState::LocalRemoved(ref reason) => {
1881                                                 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
1882                                                 } else {
1883                                                         log_warn!(logger, "Have preimage and want to fulfill HTLC with payment hash {} we already failed against channel {}", log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id()));
1884                                                         debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
1885                                                 }
1886                                                 return UpdateFulfillFetch::DuplicateClaim {};
1887                                         },
1888                                         _ => {
1889                                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
1890                                                 // Don't return in release mode here so that we can update channel_monitor
1891                                         }
1892                                 }
1893                                 pending_idx = idx;
1894                                 htlc_value_msat = htlc.amount_msat;
1895                                 break;
1896                         }
1897                 }
1898                 if pending_idx == core::usize::MAX {
1899                         #[cfg(any(test, fuzzing))]
1900                         // If we failed to find an HTLC to fulfill, make sure it was previously fulfilled and
1901                         // this is simply a duplicate claim, not previously failed and we lost funds.
1902                         debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
1903                         return UpdateFulfillFetch::DuplicateClaim {};
1904                 }
1905
1906                 // Now update local state:
1907                 //
1908                 // We have to put the payment_preimage in the channel_monitor right away here to ensure we
1909                 // can claim it even if the channel hits the chain before we see their next commitment.
1910                 self.latest_monitor_update_id += 1;
1911                 let monitor_update = ChannelMonitorUpdate {
1912                         update_id: self.latest_monitor_update_id,
1913                         updates: vec![ChannelMonitorUpdateStep::PaymentPreimage {
1914                                 payment_preimage: payment_preimage_arg.clone(),
1915                         }],
1916                 };
1917
1918                 if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
1919                         // Note that this condition is the same as the assertion in
1920                         // `claim_htlc_while_disconnected_dropping_mon_update` and must match exactly -
1921                         // `claim_htlc_while_disconnected_dropping_mon_update` would not work correctly if we
1922                         // do not not get into this branch.
1923                         for pending_update in self.holding_cell_htlc_updates.iter() {
1924                                 match pending_update {
1925                                         &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
1926                                                 if htlc_id_arg == htlc_id {
1927                                                         // Make sure we don't leave latest_monitor_update_id incremented here:
1928                                                         self.latest_monitor_update_id -= 1;
1929                                                         #[cfg(any(test, fuzzing))]
1930                                                         debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
1931                                                         return UpdateFulfillFetch::DuplicateClaim {};
1932                                                 }
1933                                         },
1934                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
1935                                                 if htlc_id_arg == htlc_id {
1936                                                         log_warn!(logger, "Have preimage and want to fulfill HTLC with pending failure against channel {}", log_bytes!(self.channel_id()));
1937                                                         // TODO: We may actually be able to switch to a fulfill here, though its
1938                                                         // rare enough it may not be worth the complexity burden.
1939                                                         debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
1940                                                         return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
1941                                                 }
1942                                         },
1943                                         _ => {}
1944                                 }
1945                         }
1946                         log_trace!(logger, "Adding HTLC claim to holding_cell in channel {}! Current state: {}", log_bytes!(self.channel_id()), self.channel_state);
1947                         self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
1948                                 payment_preimage: payment_preimage_arg, htlc_id: htlc_id_arg,
1949                         });
1950                         #[cfg(any(test, fuzzing))]
1951                         self.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
1952                         return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
1953                 }
1954                 #[cfg(any(test, fuzzing))]
1955                 self.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
1956
1957                 {
1958                         let htlc = &mut self.pending_inbound_htlcs[pending_idx];
1959                         if let InboundHTLCState::Committed = htlc.state {
1960                         } else {
1961                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
1962                                 return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
1963                         }
1964                         log_trace!(logger, "Upgrading HTLC {} to LocalRemoved with a Fulfill in channel {}!", log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
1965                         htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(payment_preimage_arg.clone()));
1966                 }
1967
1968                 UpdateFulfillFetch::NewClaim {
1969                         monitor_update,
1970                         htlc_value_msat,
1971                         msg: Some(msgs::UpdateFulfillHTLC {
1972                                 channel_id: self.channel_id(),
1973                                 htlc_id: htlc_id_arg,
1974                                 payment_preimage: payment_preimage_arg,
1975                         }),
1976                 }
1977         }
1978
1979         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 {
1980                 match self.get_update_fulfill_htlc(htlc_id, payment_preimage, logger) {
1981                         UpdateFulfillFetch::NewClaim { mut monitor_update, htlc_value_msat, msg: Some(_) } => {
1982                                 let mut additional_update = self.build_commitment_no_status_check(logger);
1983                                 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
1984                                 // strictly increasing by one, so decrement it here.
1985                                 self.latest_monitor_update_id = monitor_update.update_id;
1986                                 monitor_update.updates.append(&mut additional_update.updates);
1987                                 self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
1988                                 self.pending_monitor_updates.push(monitor_update);
1989                                 UpdateFulfillCommitFetch::NewClaim {
1990                                         monitor_update: self.pending_monitor_updates.last().unwrap(),
1991                                         htlc_value_msat,
1992                                 }
1993                         },
1994                         UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None } => {
1995                                 self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
1996                                 self.pending_monitor_updates.push(monitor_update);
1997                                 UpdateFulfillCommitFetch::NewClaim {
1998                                         monitor_update: self.pending_monitor_updates.last().unwrap(),
1999                                         htlc_value_msat,
2000                                 }
2001                         }
2002                         UpdateFulfillFetch::DuplicateClaim {} => UpdateFulfillCommitFetch::DuplicateClaim {},
2003                 }
2004         }
2005
2006         /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
2007         /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
2008         /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
2009         /// before we fail backwards.
2010         ///
2011         /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
2012         /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
2013         /// [`ChannelError::Ignore`].
2014         pub fn queue_fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, logger: &L)
2015         -> Result<(), ChannelError> where L::Target: Logger {
2016                 self.fail_htlc(htlc_id_arg, err_packet, true, logger)
2017                         .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
2018         }
2019
2020         /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
2021         /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
2022         /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
2023         /// before we fail backwards.
2024         ///
2025         /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
2026         /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
2027         /// [`ChannelError::Ignore`].
2028         fn fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, mut force_holding_cell: bool, logger: &L)
2029         -> Result<Option<msgs::UpdateFailHTLC>, ChannelError> where L::Target: Logger {
2030                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2031                         panic!("Was asked to fail an HTLC when channel was not in an operational state");
2032                 }
2033                 assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
2034
2035                 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
2036                 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
2037                 // these, but for now we just have to treat them as normal.
2038
2039                 let mut pending_idx = core::usize::MAX;
2040                 for (idx, htlc) in self.pending_inbound_htlcs.iter().enumerate() {
2041                         if htlc.htlc_id == htlc_id_arg {
2042                                 match htlc.state {
2043                                         InboundHTLCState::Committed => {},
2044                                         InboundHTLCState::LocalRemoved(ref reason) => {
2045                                                 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
2046                                                 } else {
2047                                                         debug_assert!(false, "Tried to fail an HTLC that was already failed");
2048                                                 }
2049                                                 return Ok(None);
2050                                         },
2051                                         _ => {
2052                                                 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
2053                                                 return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc.htlc_id)));
2054                                         }
2055                                 }
2056                                 pending_idx = idx;
2057                         }
2058                 }
2059                 if pending_idx == core::usize::MAX {
2060                         #[cfg(any(test, fuzzing))]
2061                         // If we failed to find an HTLC to fail, make sure it was previously fulfilled and this
2062                         // is simply a duplicate fail, not previously failed and we failed-back too early.
2063                         debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2064                         return Ok(None);
2065                 }
2066
2067                 if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
2068                         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!");
2069                         force_holding_cell = true;
2070                 }
2071
2072                 // Now update local state:
2073                 if force_holding_cell {
2074                         for pending_update in self.holding_cell_htlc_updates.iter() {
2075                                 match pending_update {
2076                                         &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
2077                                                 if htlc_id_arg == htlc_id {
2078                                                         #[cfg(any(test, fuzzing))]
2079                                                         debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2080                                                         return Ok(None);
2081                                                 }
2082                                         },
2083                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
2084                                                 if htlc_id_arg == htlc_id {
2085                                                         debug_assert!(false, "Tried to fail an HTLC that was already failed");
2086                                                         return Err(ChannelError::Ignore("Unable to find a pending HTLC which matched the given HTLC ID".to_owned()));
2087                                                 }
2088                                         },
2089                                         _ => {}
2090                                 }
2091                         }
2092                         log_trace!(logger, "Placing failure for HTLC ID {} in holding cell in channel {}.", htlc_id_arg, log_bytes!(self.channel_id()));
2093                         self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::FailHTLC {
2094                                 htlc_id: htlc_id_arg,
2095                                 err_packet,
2096                         });
2097                         return Ok(None);
2098                 }
2099
2100                 log_trace!(logger, "Failing HTLC ID {} back with a update_fail_htlc message in channel {}.", htlc_id_arg, log_bytes!(self.channel_id()));
2101                 {
2102                         let htlc = &mut self.pending_inbound_htlcs[pending_idx];
2103                         htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(err_packet.clone()));
2104                 }
2105
2106                 Ok(Some(msgs::UpdateFailHTLC {
2107                         channel_id: self.channel_id(),
2108                         htlc_id: htlc_id_arg,
2109                         reason: err_packet
2110                 }))
2111         }
2112
2113         // Message handlers:
2114
2115         pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, default_limits: &ChannelHandshakeLimits, their_features: &InitFeatures) -> Result<(), ChannelError> {
2116                 let peer_limits = if let Some(ref limits) = self.inbound_handshake_limits_override { limits } else { default_limits };
2117
2118                 // Check sanity of message fields:
2119                 if !self.is_outbound() {
2120                         return Err(ChannelError::Close("Got an accept_channel message from an inbound peer".to_owned()));
2121                 }
2122                 if self.channel_state != ChannelState::OurInitSent as u32 {
2123                         return Err(ChannelError::Close("Got an accept_channel message at a strange time".to_owned()));
2124                 }
2125                 if msg.dust_limit_satoshis > 21000000 * 100000000 {
2126                         return Err(ChannelError::Close(format!("Peer never wants payout outputs? dust_limit_satoshis was {}", msg.dust_limit_satoshis)));
2127                 }
2128                 if msg.channel_reserve_satoshis > self.channel_value_satoshis {
2129                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.channel_value_satoshis)));
2130                 }
2131                 if msg.dust_limit_satoshis > self.holder_selected_channel_reserve_satoshis {
2132                         return Err(ChannelError::Close(format!("Dust limit ({}) is bigger than our channel reserve ({})", msg.dust_limit_satoshis, self.holder_selected_channel_reserve_satoshis)));
2133                 }
2134                 if msg.channel_reserve_satoshis > self.channel_value_satoshis - self.holder_selected_channel_reserve_satoshis {
2135                         return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than channel value minus our reserve ({})",
2136                                 msg.channel_reserve_satoshis, self.channel_value_satoshis - self.holder_selected_channel_reserve_satoshis)));
2137                 }
2138                 let full_channel_value_msat = (self.channel_value_satoshis - msg.channel_reserve_satoshis) * 1000;
2139                 if msg.htlc_minimum_msat >= full_channel_value_msat {
2140                         return Err(ChannelError::Close(format!("Minimum htlc value ({}) is full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
2141                 }
2142                 let max_delay_acceptable = u16::min(peer_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
2143                 if msg.to_self_delay > max_delay_acceptable {
2144                         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)));
2145                 }
2146                 if msg.max_accepted_htlcs < 1 {
2147                         return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
2148                 }
2149                 if msg.max_accepted_htlcs > MAX_HTLCS {
2150                         return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
2151                 }
2152
2153                 // Now check against optional parameters as set by config...
2154                 if msg.htlc_minimum_msat > peer_limits.max_htlc_minimum_msat {
2155                         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)));
2156                 }
2157                 if msg.max_htlc_value_in_flight_msat < peer_limits.min_max_htlc_value_in_flight_msat {
2158                         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)));
2159                 }
2160                 if msg.channel_reserve_satoshis > peer_limits.max_channel_reserve_satoshis {
2161                         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)));
2162                 }
2163                 if msg.max_accepted_htlcs < peer_limits.min_max_accepted_htlcs {
2164                         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)));
2165                 }
2166                 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
2167                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
2168                 }
2169                 if msg.dust_limit_satoshis > MAX_CHAN_DUST_LIMIT_SATOSHIS {
2170                         return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
2171                 }
2172                 if msg.minimum_depth > peer_limits.max_minimum_depth {
2173                         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)));
2174                 }
2175
2176                 if let Some(ty) = &msg.channel_type {
2177                         if *ty != self.channel_type {
2178                                 return Err(ChannelError::Close("Channel Type in accept_channel didn't match the one sent in open_channel.".to_owned()));
2179                         }
2180                 } else if their_features.supports_channel_type() {
2181                         // Assume they've accepted the channel type as they said they understand it.
2182                 } else {
2183                         let channel_type = ChannelTypeFeatures::from_init(&their_features);
2184                         if channel_type != ChannelTypeFeatures::only_static_remote_key() {
2185                                 return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
2186                         }
2187                         self.channel_type = channel_type;
2188                 }
2189
2190                 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
2191                         match &msg.shutdown_scriptpubkey {
2192                                 &OptionalField::Present(ref script) => {
2193                                         // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
2194                                         if script.len() == 0 {
2195                                                 None
2196                                         } else {
2197                                                 if !script::is_bolt2_compliant(&script, their_features) {
2198                                                         return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)));
2199                                                 }
2200                                                 Some(script.clone())
2201                                         }
2202                                 },
2203                                 // 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
2204                                 &OptionalField::Absent => {
2205                                         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()));
2206                                 }
2207                         }
2208                 } else { None };
2209
2210                 self.counterparty_dust_limit_satoshis = msg.dust_limit_satoshis;
2211                 self.counterparty_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.channel_value_satoshis * 1000);
2212                 self.counterparty_selected_channel_reserve_satoshis = Some(msg.channel_reserve_satoshis);
2213                 self.counterparty_htlc_minimum_msat = msg.htlc_minimum_msat;
2214                 self.counterparty_max_accepted_htlcs = msg.max_accepted_htlcs;
2215
2216                 if peer_limits.trust_own_funding_0conf {
2217                         self.minimum_depth = Some(msg.minimum_depth);
2218                 } else {
2219                         self.minimum_depth = Some(cmp::max(1, msg.minimum_depth));
2220                 }
2221
2222                 let counterparty_pubkeys = ChannelPublicKeys {
2223                         funding_pubkey: msg.funding_pubkey,
2224                         revocation_basepoint: msg.revocation_basepoint,
2225                         payment_point: msg.payment_point,
2226                         delayed_payment_basepoint: msg.delayed_payment_basepoint,
2227                         htlc_basepoint: msg.htlc_basepoint
2228                 };
2229
2230                 self.channel_transaction_parameters.counterparty_parameters = Some(CounterpartyChannelTransactionParameters {
2231                         selected_contest_delay: msg.to_self_delay,
2232                         pubkeys: counterparty_pubkeys,
2233                 });
2234
2235                 self.counterparty_cur_commitment_point = Some(msg.first_per_commitment_point);
2236                 self.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;
2237
2238                 self.channel_state = ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32;
2239                 self.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.
2240
2241                 Ok(())
2242         }
2243
2244         fn funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<(Txid, CommitmentTransaction, Signature), ChannelError> where L::Target: Logger {
2245                 let funding_script = self.get_funding_redeemscript();
2246
2247                 let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
2248                 let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, logger).tx;
2249                 {
2250                         let trusted_tx = initial_commitment_tx.trust();
2251                         let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
2252                         let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
2253                         // They sign the holder commitment transaction...
2254                         log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} for channel {}.",
2255                                 log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.counterparty_funding_pubkey().serialize()),
2256                                 encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]),
2257                                 encode::serialize_hex(&funding_script), log_bytes!(self.channel_id()));
2258                         secp_check!(self.secp_ctx.verify_ecdsa(&sighash, &sig, self.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
2259                 }
2260
2261                 let counterparty_keys = self.build_remote_transaction_keys();
2262                 let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
2263
2264                 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
2265                 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
2266                 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
2267                         log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
2268
2269                 let counterparty_signature = self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
2270                                 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
2271
2272                 // We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
2273                 Ok((counterparty_initial_bitcoin_tx.txid, initial_commitment_tx, counterparty_signature))
2274         }
2275
2276         fn counterparty_funding_pubkey(&self) -> &PublicKey {
2277                 &self.get_counterparty_pubkeys().funding_pubkey
2278         }
2279
2280         pub fn funding_created<SP: Deref, L: Deref>(
2281                 &mut self, msg: &msgs::FundingCreated, best_block: BestBlock, signer_provider: &SP, logger: &L
2282         ) -> Result<(msgs::FundingSigned, ChannelMonitor<Signer>), ChannelError>
2283         where
2284                 SP::Target: SignerProvider<Signer = Signer>,
2285                 L::Target: Logger
2286         {
2287                 if self.is_outbound() {
2288                         return Err(ChannelError::Close("Received funding_created for an outbound channel?".to_owned()));
2289                 }
2290                 if self.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
2291                         // BOLT 2 says that if we disconnect before we send funding_signed we SHOULD NOT
2292                         // remember the channel, so it's safe to just send an error_message here and drop the
2293                         // channel.
2294                         return Err(ChannelError::Close("Received funding_created after we got the channel!".to_owned()));
2295                 }
2296                 if self.inbound_awaiting_accept {
2297                         return Err(ChannelError::Close("FundingCreated message received before the channel was accepted".to_owned()));
2298                 }
2299                 if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
2300                                 self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
2301                                 self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
2302                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
2303                 }
2304
2305                 let funding_txo = OutPoint { txid: msg.funding_txid, index: msg.funding_output_index };
2306                 self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
2307                 // This is an externally observable change before we finish all our checks.  In particular
2308                 // funding_created_signature may fail.
2309                 self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
2310
2311                 let (counterparty_initial_commitment_txid, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
2312                         Ok(res) => res,
2313                         Err(ChannelError::Close(e)) => {
2314                                 self.channel_transaction_parameters.funding_outpoint = None;
2315                                 return Err(ChannelError::Close(e));
2316                         },
2317                         Err(e) => {
2318                                 // The only error we know how to handle is ChannelError::Close, so we fall over here
2319                                 // to make sure we don't continue with an inconsistent state.
2320                                 panic!("unexpected error type from funding_created_signature {:?}", e);
2321                         }
2322                 };
2323
2324                 let holder_commitment_tx = HolderCommitmentTransaction::new(
2325                         initial_commitment_tx,
2326                         msg.signature,
2327                         Vec::new(),
2328                         &self.get_holder_pubkeys().funding_pubkey,
2329                         self.counterparty_funding_pubkey()
2330                 );
2331
2332                 self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
2333                         .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
2334
2335                 // Now that we're past error-generating stuff, update our local state:
2336
2337                 let funding_redeemscript = self.get_funding_redeemscript();
2338                 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
2339                 let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound());
2340                 let shutdown_script = self.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
2341                 let mut monitor_signer = signer_provider.derive_channel_signer(self.channel_value_satoshis, self.channel_keys_id);
2342                 monitor_signer.provide_channel_parameters(&self.channel_transaction_parameters);
2343                 let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), monitor_signer,
2344                                                           shutdown_script, self.get_holder_selected_contest_delay(),
2345                                                           &self.destination_script, (funding_txo, funding_txo_script.clone()),
2346                                                           &self.channel_transaction_parameters,
2347                                                           funding_redeemscript.clone(), self.channel_value_satoshis,
2348                                                           obscure_factor,
2349                                                           holder_commitment_tx, best_block, self.counterparty_node_id);
2350
2351                 channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_commitment_txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
2352
2353                 self.channel_state = ChannelState::FundingSent as u32;
2354                 self.channel_id = funding_txo.to_channel_id();
2355                 self.cur_counterparty_commitment_transaction_number -= 1;
2356                 self.cur_holder_commitment_transaction_number -= 1;
2357
2358                 log_info!(logger, "Generated funding_signed for peer for channel {}", log_bytes!(self.channel_id()));
2359
2360                 let need_channel_ready = self.check_get_channel_ready(0).is_some();
2361                 self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
2362
2363                 Ok((msgs::FundingSigned {
2364                         channel_id: self.channel_id,
2365                         signature,
2366                         #[cfg(taproot)]
2367                         partial_signature_with_nonce: None,
2368                 }, channel_monitor))
2369         }
2370
2371         /// Handles a funding_signed message from the remote end.
2372         /// If this call is successful, broadcast the funding transaction (and not before!)
2373         pub fn funding_signed<SP: Deref, L: Deref>(
2374                 &mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
2375         ) -> Result<ChannelMonitor<Signer>, ChannelError>
2376         where
2377                 SP::Target: SignerProvider<Signer = Signer>,
2378                 L::Target: Logger
2379         {
2380                 if !self.is_outbound() {
2381                         return Err(ChannelError::Close("Received funding_signed for an inbound channel?".to_owned()));
2382                 }
2383                 if self.channel_state & !(ChannelState::MonitorUpdateInProgress as u32) != ChannelState::FundingCreated as u32 {
2384                         return Err(ChannelError::Close("Received funding_signed in strange state!".to_owned()));
2385                 }
2386                 if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
2387                                 self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
2388                                 self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
2389                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
2390                 }
2391
2392                 let funding_script = self.get_funding_redeemscript();
2393
2394                 let counterparty_keys = self.build_remote_transaction_keys();
2395                 let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
2396                 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
2397                 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
2398
2399                 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
2400                         log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
2401
2402                 let holder_signer = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
2403                 let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &holder_signer, true, false, logger).tx;
2404                 {
2405                         let trusted_tx = initial_commitment_tx.trust();
2406                         let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
2407                         let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
2408                         // They sign our commitment transaction, allowing us to broadcast the tx if we wish.
2409                         if let Err(_) = self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
2410                                 return Err(ChannelError::Close("Invalid funding_signed signature from peer".to_owned()));
2411                         }
2412                 }
2413
2414                 let holder_commitment_tx = HolderCommitmentTransaction::new(
2415                         initial_commitment_tx,
2416                         msg.signature,
2417                         Vec::new(),
2418                         &self.get_holder_pubkeys().funding_pubkey,
2419                         self.counterparty_funding_pubkey()
2420                 );
2421
2422                 self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
2423                         .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
2424
2425
2426                 let funding_redeemscript = self.get_funding_redeemscript();
2427                 let funding_txo = self.get_funding_txo().unwrap();
2428                 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
2429                 let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound());
2430                 let shutdown_script = self.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
2431                 let mut monitor_signer = signer_provider.derive_channel_signer(self.channel_value_satoshis, self.channel_keys_id);
2432                 monitor_signer.provide_channel_parameters(&self.channel_transaction_parameters);
2433                 let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), monitor_signer,
2434                                                           shutdown_script, self.get_holder_selected_contest_delay(),
2435                                                           &self.destination_script, (funding_txo, funding_txo_script),
2436                                                           &self.channel_transaction_parameters,
2437                                                           funding_redeemscript.clone(), self.channel_value_satoshis,
2438                                                           obscure_factor,
2439                                                           holder_commitment_tx, best_block, self.counterparty_node_id);
2440
2441                 channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_bitcoin_tx.txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
2442
2443                 assert_eq!(self.channel_state & (ChannelState::MonitorUpdateInProgress as u32), 0); // We have no had any monitor(s) yet to fail update!
2444                 self.channel_state = ChannelState::FundingSent as u32;
2445                 self.cur_holder_commitment_transaction_number -= 1;
2446                 self.cur_counterparty_commitment_transaction_number -= 1;
2447
2448                 log_info!(logger, "Received funding_signed from peer for channel {}", log_bytes!(self.channel_id()));
2449
2450                 let need_channel_ready = self.check_get_channel_ready(0).is_some();
2451                 self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
2452                 Ok(channel_monitor)
2453         }
2454
2455         /// Handles a channel_ready message from our peer. If we've already sent our channel_ready
2456         /// and the channel is now usable (and public), this may generate an announcement_signatures to
2457         /// reply with.
2458         pub fn channel_ready<NS: Deref, L: Deref>(
2459                 &mut self, msg: &msgs::ChannelReady, node_signer: &NS, genesis_block_hash: BlockHash,
2460                 user_config: &UserConfig, best_block: &BestBlock, logger: &L
2461         ) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError>
2462         where
2463                 NS::Target: NodeSigner,
2464                 L::Target: Logger
2465         {
2466                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2467                         self.workaround_lnd_bug_4006 = Some(msg.clone());
2468                         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()));
2469                 }
2470
2471                 if let Some(scid_alias) = msg.short_channel_id_alias {
2472                         if Some(scid_alias) != self.short_channel_id {
2473                                 // The scid alias provided can be used to route payments *from* our counterparty,
2474                                 // i.e. can be used for inbound payments and provided in invoices, but is not used
2475                                 // when routing outbound payments.
2476                                 self.latest_inbound_scid_alias = Some(scid_alias);
2477                         }
2478                 }
2479
2480                 let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
2481
2482                 if non_shutdown_state == ChannelState::FundingSent as u32 {
2483                         self.channel_state |= ChannelState::TheirChannelReady as u32;
2484                 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
2485                         self.channel_state = ChannelState::ChannelReady as u32 | (self.channel_state & MULTI_STATE_FLAGS);
2486                         self.update_time_counter += 1;
2487                 } else if self.channel_state & (ChannelState::ChannelReady as u32) != 0 ||
2488                         // If we reconnected before sending our `channel_ready` they may still resend theirs:
2489                         (self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) ==
2490                                               (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32))
2491                 {
2492                         // They probably disconnected/reconnected and re-sent the channel_ready, which is
2493                         // required, or they're sending a fresh SCID alias.
2494                         let expected_point =
2495                                 if self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
2496                                         // If they haven't ever sent an updated point, the point they send should match
2497                                         // the current one.
2498                                         self.counterparty_cur_commitment_point
2499                                 } else if self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
2500                                         // If we've advanced the commitment number once, the second commitment point is
2501                                         // at `counterparty_prev_commitment_point`, which is not yet revoked.
2502                                         debug_assert!(self.counterparty_prev_commitment_point.is_some());
2503                                         self.counterparty_prev_commitment_point
2504                                 } else {
2505                                         // If they have sent updated points, channel_ready is always supposed to match
2506                                         // their "first" point, which we re-derive here.
2507                                         Some(PublicKey::from_secret_key(&self.secp_ctx, &SecretKey::from_slice(
2508                                                         &self.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
2509                                                 ).expect("We already advanced, so previous secret keys should have been validated already")))
2510                                 };
2511                         if expected_point != Some(msg.next_per_commitment_point) {
2512                                 return Err(ChannelError::Close("Peer sent a reconnect channel_ready with a different point".to_owned()));
2513                         }
2514                         return Ok(None);
2515                 } else {
2516                         return Err(ChannelError::Close("Peer sent a channel_ready at a strange time".to_owned()));
2517                 }
2518
2519                 self.counterparty_prev_commitment_point = self.counterparty_cur_commitment_point;
2520                 self.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
2521
2522                 log_info!(logger, "Received channel_ready from peer for channel {}", log_bytes!(self.channel_id()));
2523
2524                 Ok(self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block.height(), logger))
2525         }
2526
2527         /// Returns transaction if there is pending funding transaction that is yet to broadcast
2528         pub fn unbroadcasted_funding(&self) -> Option<Transaction> {
2529                 if self.channel_state & (ChannelState::FundingCreated as u32) != 0 {
2530                         self.funding_transaction.clone()
2531                 } else {
2532                         None
2533                 }
2534         }
2535
2536         /// Returns a HTLCStats about inbound pending htlcs
2537         fn get_inbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
2538                 let mut stats = HTLCStats {
2539                         pending_htlcs: self.pending_inbound_htlcs.len() as u32,
2540                         pending_htlcs_value_msat: 0,
2541                         on_counterparty_tx_dust_exposure_msat: 0,
2542                         on_holder_tx_dust_exposure_msat: 0,
2543                         holding_cell_msat: 0,
2544                         on_holder_tx_holding_cell_htlcs_count: 0,
2545                 };
2546
2547                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if self.opt_anchors() {
2548                         (0, 0)
2549                 } else {
2550                         let dust_buffer_feerate = self.get_dust_buffer_feerate(outbound_feerate_update) as u64;
2551                         (dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
2552                                 dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
2553                 };
2554                 let counterparty_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
2555                 let holder_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
2556                 for ref htlc in self.pending_inbound_htlcs.iter() {
2557                         stats.pending_htlcs_value_msat += htlc.amount_msat;
2558                         if htlc.amount_msat / 1000 < counterparty_dust_limit_timeout_sat {
2559                                 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
2560                         }
2561                         if htlc.amount_msat / 1000 < holder_dust_limit_success_sat {
2562                                 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
2563                         }
2564                 }
2565                 stats
2566         }
2567
2568         /// Returns a HTLCStats about pending outbound htlcs, *including* pending adds in our holding cell.
2569         fn get_outbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
2570                 let mut stats = HTLCStats {
2571                         pending_htlcs: self.pending_outbound_htlcs.len() as u32,
2572                         pending_htlcs_value_msat: 0,
2573                         on_counterparty_tx_dust_exposure_msat: 0,
2574                         on_holder_tx_dust_exposure_msat: 0,
2575                         holding_cell_msat: 0,
2576                         on_holder_tx_holding_cell_htlcs_count: 0,
2577                 };
2578
2579                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if self.opt_anchors() {
2580                         (0, 0)
2581                 } else {
2582                         let dust_buffer_feerate = self.get_dust_buffer_feerate(outbound_feerate_update) as u64;
2583                         (dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
2584                                 dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
2585                 };
2586                 let counterparty_dust_limit_success_sat = htlc_success_dust_limit + self.counterparty_dust_limit_satoshis;
2587                 let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
2588                 for ref htlc in self.pending_outbound_htlcs.iter() {
2589                         stats.pending_htlcs_value_msat += htlc.amount_msat;
2590                         if htlc.amount_msat / 1000 < counterparty_dust_limit_success_sat {
2591                                 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
2592                         }
2593                         if htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat {
2594                                 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
2595                         }
2596                 }
2597
2598                 for update in self.holding_cell_htlc_updates.iter() {
2599                         if let &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, .. } = update {
2600                                 stats.pending_htlcs += 1;
2601                                 stats.pending_htlcs_value_msat += amount_msat;
2602                                 stats.holding_cell_msat += amount_msat;
2603                                 if *amount_msat / 1000 < counterparty_dust_limit_success_sat {
2604                                         stats.on_counterparty_tx_dust_exposure_msat += amount_msat;
2605                                 }
2606                                 if *amount_msat / 1000 < holder_dust_limit_timeout_sat {
2607                                         stats.on_holder_tx_dust_exposure_msat += amount_msat;
2608                                 } else {
2609                                         stats.on_holder_tx_holding_cell_htlcs_count += 1;
2610                                 }
2611                         }
2612                 }
2613                 stats
2614         }
2615
2616         /// Get the available balances, see [`AvailableBalances`]'s fields for more info.
2617         /// Doesn't bother handling the
2618         /// if-we-removed-it-already-but-haven't-fully-resolved-they-can-still-send-an-inbound-HTLC
2619         /// corner case properly.
2620         pub fn get_available_balances(&self) -> AvailableBalances {
2621                 // Note that we have to handle overflow due to the above case.
2622                 let outbound_stats = self.get_outbound_pending_htlc_stats(None);
2623
2624                 let mut balance_msat = self.value_to_self_msat;
2625                 for ref htlc in self.pending_inbound_htlcs.iter() {
2626                         if let InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) = htlc.state {
2627                                 balance_msat += htlc.amount_msat;
2628                         }
2629                 }
2630                 balance_msat -= outbound_stats.pending_htlcs_value_msat;
2631
2632                 let outbound_capacity_msat = cmp::max(self.value_to_self_msat as i64
2633                                 - outbound_stats.pending_htlcs_value_msat as i64
2634                                 - self.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) as i64 * 1000,
2635                         0) as u64;
2636                 AvailableBalances {
2637                         inbound_capacity_msat: cmp::max(self.channel_value_satoshis as i64 * 1000
2638                                         - self.value_to_self_msat as i64
2639                                         - self.get_inbound_pending_htlc_stats(None).pending_htlcs_value_msat as i64
2640                                         - self.holder_selected_channel_reserve_satoshis as i64 * 1000,
2641                                 0) as u64,
2642                         outbound_capacity_msat,
2643                         next_outbound_htlc_limit_msat: cmp::max(cmp::min(outbound_capacity_msat as i64,
2644                                         self.counterparty_max_htlc_value_in_flight_msat as i64
2645                                                 - outbound_stats.pending_htlcs_value_msat as i64),
2646                                 0) as u64,
2647                         balance_msat,
2648                 }
2649         }
2650
2651         pub fn get_holder_counterparty_selected_channel_reserve_satoshis(&self) -> (u64, Option<u64>) {
2652                 (self.holder_selected_channel_reserve_satoshis, self.counterparty_selected_channel_reserve_satoshis)
2653         }
2654
2655         // Get the fee cost in MSATS of a commitment tx with a given number of HTLC outputs.
2656         // Note that num_htlcs should not include dust HTLCs.
2657         fn commit_tx_fee_msat(feerate_per_kw: u32, num_htlcs: usize, opt_anchors: bool) -> u64 {
2658                 // Note that we need to divide before multiplying to round properly,
2659                 // since the lowest denomination of bitcoin on-chain is the satoshi.
2660                 (commitment_tx_base_weight(opt_anchors) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate_per_kw as u64 / 1000 * 1000
2661         }
2662
2663         // Get the fee cost in SATS of a commitment tx with a given number of HTLC outputs.
2664         // Note that num_htlcs should not include dust HTLCs.
2665         #[inline]
2666         fn commit_tx_fee_sat(feerate_per_kw: u32, num_htlcs: usize, opt_anchors: bool) -> u64 {
2667                 feerate_per_kw as u64 * (commitment_tx_base_weight(opt_anchors) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
2668         }
2669
2670         // Get the commitment tx fee for the local's (i.e. our) next commitment transaction based on the
2671         // number of pending HTLCs that are on track to be in our next commitment tx, plus an additional
2672         // HTLC if `fee_spike_buffer_htlc` is Some, plus a new HTLC given by `new_htlc_amount`. Dust HTLCs
2673         // are excluded.
2674         fn next_local_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
2675                 assert!(self.is_outbound());
2676
2677                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
2678                         (0, 0)
2679                 } else {
2680                         (self.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
2681                                 self.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
2682                 };
2683                 let real_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
2684                 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
2685
2686                 let mut addl_htlcs = 0;
2687                 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
2688                 match htlc.origin {
2689                         HTLCInitiator::LocalOffered => {
2690                                 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
2691                                         addl_htlcs += 1;
2692                                 }
2693                         },
2694                         HTLCInitiator::RemoteOffered => {
2695                                 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
2696                                         addl_htlcs += 1;
2697                                 }
2698                         }
2699                 }
2700
2701                 let mut included_htlcs = 0;
2702                 for ref htlc in self.pending_inbound_htlcs.iter() {
2703                         if htlc.amount_msat / 1000 < real_dust_limit_success_sat {
2704                                 continue
2705                         }
2706                         // We include LocalRemoved HTLCs here because we may still need to broadcast a commitment
2707                         // transaction including this HTLC if it times out before they RAA.
2708                         included_htlcs += 1;
2709                 }
2710
2711                 for ref htlc in self.pending_outbound_htlcs.iter() {
2712                         if htlc.amount_msat / 1000 < real_dust_limit_timeout_sat {
2713                                 continue
2714                         }
2715                         match htlc.state {
2716                                 OutboundHTLCState::LocalAnnounced {..} => included_htlcs += 1,
2717                                 OutboundHTLCState::Committed => included_htlcs += 1,
2718                                 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
2719                                 // We don't include AwaitingRemoteRevokeToRemove HTLCs because our next commitment
2720                                 // transaction won't be generated until they send us their next RAA, which will mean
2721                                 // dropping any HTLCs in this state.
2722                                 _ => {},
2723                         }
2724                 }
2725
2726                 for htlc in self.holding_cell_htlc_updates.iter() {
2727                         match htlc {
2728                                 &HTLCUpdateAwaitingACK::AddHTLC { amount_msat, .. } => {
2729                                         if amount_msat / 1000 < real_dust_limit_timeout_sat {
2730                                                 continue
2731                                         }
2732                                         included_htlcs += 1
2733                                 },
2734                                 _ => {}, // Don't include claims/fails that are awaiting ack, because once we get the
2735                                          // ack we're guaranteed to never include them in commitment txs anymore.
2736                         }
2737                 }
2738
2739                 let num_htlcs = included_htlcs + addl_htlcs;
2740                 let res = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs, self.opt_anchors());
2741                 #[cfg(any(test, fuzzing))]
2742                 {
2743                         let mut fee = res;
2744                         if fee_spike_buffer_htlc.is_some() {
2745                                 fee = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
2746                         }
2747                         let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len()
2748                                 + self.holding_cell_htlc_updates.len();
2749                         let commitment_tx_info = CommitmentTxInfoCached {
2750                                 fee,
2751                                 total_pending_htlcs,
2752                                 next_holder_htlc_id: match htlc.origin {
2753                                         HTLCInitiator::LocalOffered => self.next_holder_htlc_id + 1,
2754                                         HTLCInitiator::RemoteOffered => self.next_holder_htlc_id,
2755                                 },
2756                                 next_counterparty_htlc_id: match htlc.origin {
2757                                         HTLCInitiator::LocalOffered => self.next_counterparty_htlc_id,
2758                                         HTLCInitiator::RemoteOffered => self.next_counterparty_htlc_id + 1,
2759                                 },
2760                                 feerate: self.feerate_per_kw,
2761                         };
2762                         *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
2763                 }
2764                 res
2765         }
2766
2767         // Get the commitment tx fee for the remote's next commitment transaction based on the number of
2768         // pending HTLCs that are on track to be in their next commitment tx, plus an additional HTLC if
2769         // `fee_spike_buffer_htlc` is Some, plus a new HTLC given by `new_htlc_amount`. Dust HTLCs are
2770         // excluded.
2771         fn next_remote_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
2772                 assert!(!self.is_outbound());
2773
2774                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
2775                         (0, 0)
2776                 } else {
2777                         (self.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
2778                                 self.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
2779                 };
2780                 let real_dust_limit_success_sat = htlc_success_dust_limit + self.counterparty_dust_limit_satoshis;
2781                 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
2782
2783                 let mut addl_htlcs = 0;
2784                 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
2785                 match htlc.origin {
2786                         HTLCInitiator::LocalOffered => {
2787                                 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
2788                                         addl_htlcs += 1;
2789                                 }
2790                         },
2791                         HTLCInitiator::RemoteOffered => {
2792                                 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
2793                                         addl_htlcs += 1;
2794                                 }
2795                         }
2796                 }
2797
2798                 // When calculating the set of HTLCs which will be included in their next commitment_signed, all
2799                 // non-dust inbound HTLCs are included (as all states imply it will be included) and only
2800                 // committed outbound HTLCs, see below.
2801                 let mut included_htlcs = 0;
2802                 for ref htlc in self.pending_inbound_htlcs.iter() {
2803                         if htlc.amount_msat / 1000 <= real_dust_limit_timeout_sat {
2804                                 continue
2805                         }
2806                         included_htlcs += 1;
2807                 }
2808
2809                 for ref htlc in self.pending_outbound_htlcs.iter() {
2810                         if htlc.amount_msat / 1000 <= real_dust_limit_success_sat {
2811                                 continue
2812                         }
2813                         // We only include outbound HTLCs if it will not be included in their next commitment_signed,
2814                         // i.e. if they've responded to us with an RAA after announcement.
2815                         match htlc.state {
2816                                 OutboundHTLCState::Committed => included_htlcs += 1,
2817                                 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
2818                                 OutboundHTLCState::LocalAnnounced { .. } => included_htlcs += 1,
2819                                 _ => {},
2820                         }
2821                 }
2822
2823                 let num_htlcs = included_htlcs + addl_htlcs;
2824                 let res = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs, self.opt_anchors());
2825                 #[cfg(any(test, fuzzing))]
2826                 {
2827                         let mut fee = res;
2828                         if fee_spike_buffer_htlc.is_some() {
2829                                 fee = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
2830                         }
2831                         let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
2832                         let commitment_tx_info = CommitmentTxInfoCached {
2833                                 fee,
2834                                 total_pending_htlcs,
2835                                 next_holder_htlc_id: match htlc.origin {
2836                                         HTLCInitiator::LocalOffered => self.next_holder_htlc_id + 1,
2837                                         HTLCInitiator::RemoteOffered => self.next_holder_htlc_id,
2838                                 },
2839                                 next_counterparty_htlc_id: match htlc.origin {
2840                                         HTLCInitiator::LocalOffered => self.next_counterparty_htlc_id,
2841                                         HTLCInitiator::RemoteOffered => self.next_counterparty_htlc_id + 1,
2842                                 },
2843                                 feerate: self.feerate_per_kw,
2844                         };
2845                         *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
2846                 }
2847                 res
2848         }
2849
2850         pub fn update_add_htlc<F, L: Deref>(&mut self, msg: &msgs::UpdateAddHTLC, mut pending_forward_status: PendingHTLCStatus, create_pending_htlc_status: F, logger: &L) -> Result<(), ChannelError>
2851         where F: for<'a> Fn(&'a Self, PendingHTLCStatus, u16) -> PendingHTLCStatus, L::Target: Logger {
2852                 // We can't accept HTLCs sent after we've sent a shutdown.
2853                 let local_sent_shutdown = (self.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::LocalShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
2854                 if local_sent_shutdown {
2855                         pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x4000|8);
2856                 }
2857                 // If the remote has sent a shutdown prior to adding this HTLC, then they are in violation of the spec.
2858                 let remote_sent_shutdown = (self.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::RemoteShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
2859                 if remote_sent_shutdown {
2860                         return Err(ChannelError::Close("Got add HTLC message when channel was not in an operational state".to_owned()));
2861                 }
2862                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2863                         return Err(ChannelError::Close("Peer sent update_add_htlc when we needed a channel_reestablish".to_owned()));
2864                 }
2865                 if msg.amount_msat > self.channel_value_satoshis * 1000 {
2866                         return Err(ChannelError::Close("Remote side tried to send more than the total value of the channel".to_owned()));
2867                 }
2868                 if msg.amount_msat == 0 {
2869                         return Err(ChannelError::Close("Remote side tried to send a 0-msat HTLC".to_owned()));
2870                 }
2871                 if msg.amount_msat < self.holder_htlc_minimum_msat {
2872                         return Err(ChannelError::Close(format!("Remote side tried to send less than our minimum HTLC value. Lower limit: ({}). Actual: ({})", self.holder_htlc_minimum_msat, msg.amount_msat)));
2873                 }
2874
2875                 let inbound_stats = self.get_inbound_pending_htlc_stats(None);
2876                 let outbound_stats = self.get_outbound_pending_htlc_stats(None);
2877                 if inbound_stats.pending_htlcs + 1 > OUR_MAX_HTLCS as u32 {
2878                         return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", OUR_MAX_HTLCS)));
2879                 }
2880                 if inbound_stats.pending_htlcs_value_msat + msg.amount_msat > self.holder_max_htlc_value_in_flight_msat {
2881                         return Err(ChannelError::Close(format!("Remote HTLC add would put them over our max HTLC value ({})", self.holder_max_htlc_value_in_flight_msat)));
2882                 }
2883                 // Check holder_selected_channel_reserve_satoshis (we're getting paid, so they have to at least meet
2884                 // the reserve_satoshis we told them to always have as direct payment so that they lose
2885                 // something if we punish them for broadcasting an old state).
2886                 // Note that we don't really care about having a small/no to_remote output in our local
2887                 // commitment transactions, as the purpose of the channel reserve is to ensure we can
2888                 // punish *them* if they misbehave, so we discount any outbound HTLCs which will not be
2889                 // present in the next commitment transaction we send them (at least for fulfilled ones,
2890                 // failed ones won't modify value_to_self).
2891                 // Note that we will send HTLCs which another instance of rust-lightning would think
2892                 // violate the reserve value if we do not do this (as we forget inbound HTLCs from the
2893                 // Channel state once they will not be present in the next received commitment
2894                 // transaction).
2895                 let mut removed_outbound_total_msat = 0;
2896                 for ref htlc in self.pending_outbound_htlcs.iter() {
2897                         if let OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_)) = htlc.state {
2898                                 removed_outbound_total_msat += htlc.amount_msat;
2899                         } else if let OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) = htlc.state {
2900                                 removed_outbound_total_msat += htlc.amount_msat;
2901                         }
2902                 }
2903
2904                 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if self.opt_anchors() {
2905                         (0, 0)
2906                 } else {
2907                         let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
2908                         (dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
2909                                 dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
2910                 };
2911                 let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
2912                 if msg.amount_msat / 1000 < exposure_dust_limit_timeout_sats {
2913                         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;
2914                         if on_counterparty_tx_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
2915                                 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on counterparty commitment tx",
2916                                         on_counterparty_tx_dust_htlc_exposure_msat, self.get_max_dust_htlc_exposure_msat());
2917                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2918                         }
2919                 }
2920
2921                 let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
2922                 if msg.amount_msat / 1000 < exposure_dust_limit_success_sats {
2923                         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;
2924                         if on_holder_tx_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
2925                                 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on holder commitment tx",
2926                                         on_holder_tx_dust_htlc_exposure_msat, self.get_max_dust_htlc_exposure_msat());
2927                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2928                         }
2929                 }
2930
2931                 let pending_value_to_self_msat =
2932                         self.value_to_self_msat + inbound_stats.pending_htlcs_value_msat - removed_outbound_total_msat;
2933                 let pending_remote_value_msat =
2934                         self.channel_value_satoshis * 1000 - pending_value_to_self_msat;
2935                 if pending_remote_value_msat < msg.amount_msat {
2936                         return Err(ChannelError::Close("Remote HTLC add would overdraw remaining funds".to_owned()));
2937                 }
2938
2939                 // Check that the remote can afford to pay for this HTLC on-chain at the current
2940                 // feerate_per_kw, while maintaining their channel reserve (as required by the spec).
2941                 let remote_commit_tx_fee_msat = if self.is_outbound() { 0 } else {
2942                         let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2943                         self.next_remote_commit_tx_fee_msat(htlc_candidate, None) // Don't include the extra fee spike buffer HTLC in calculations
2944                 };
2945                 if pending_remote_value_msat - msg.amount_msat < remote_commit_tx_fee_msat {
2946                         return Err(ChannelError::Close("Remote HTLC add would not leave enough to pay for fees".to_owned()));
2947                 };
2948
2949                 if pending_remote_value_msat - msg.amount_msat - remote_commit_tx_fee_msat < self.holder_selected_channel_reserve_satoshis * 1000 {
2950                         return Err(ChannelError::Close("Remote HTLC add would put them under remote reserve value".to_owned()));
2951                 }
2952
2953                 if !self.is_outbound() {
2954                         // `2 *` and `Some(())` is for the fee spike buffer we keep for the remote. This deviates from
2955                         // the spec because in the spec, the fee spike buffer requirement doesn't exist on the
2956                         // receiver's side, only on the sender's.
2957                         // Note that when we eventually remove support for fee updates and switch to anchor output
2958                         // fees, we will drop the `2 *`, since we no longer be as sensitive to fee spikes. But, keep
2959                         // the extra htlc when calculating the next remote commitment transaction fee as we should
2960                         // still be able to afford adding this HTLC plus one more future HTLC, regardless of being
2961                         // sensitive to fee spikes.
2962                         let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2963                         let remote_fee_cost_incl_stuck_buffer_msat = 2 * self.next_remote_commit_tx_fee_msat(htlc_candidate, Some(()));
2964                         if pending_remote_value_msat - msg.amount_msat - self.holder_selected_channel_reserve_satoshis * 1000 < remote_fee_cost_incl_stuck_buffer_msat {
2965                                 // Note that if the pending_forward_status is not updated here, then it's because we're already failing
2966                                 // the HTLC, i.e. its status is already set to failing.
2967                                 log_info!(logger, "Attempting to fail HTLC due to fee spike buffer violation in channel {}. Rebalancing is required.", log_bytes!(self.channel_id()));
2968                                 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2969                         }
2970                 } else {
2971                         // Check that they won't violate our local required channel reserve by adding this HTLC.
2972                         let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2973                         let local_commit_tx_fee_msat = self.next_local_commit_tx_fee_msat(htlc_candidate, None);
2974                         if self.value_to_self_msat < self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 + local_commit_tx_fee_msat {
2975                                 return Err(ChannelError::Close("Cannot accept HTLC that would put our balance under counterparty-announced channel reserve value".to_owned()));
2976                         }
2977                 }
2978                 if self.next_counterparty_htlc_id != msg.htlc_id {
2979                         return Err(ChannelError::Close(format!("Remote skipped HTLC ID (skipped ID: {})", self.next_counterparty_htlc_id)));
2980                 }
2981                 if msg.cltv_expiry >= 500000000 {
2982                         return Err(ChannelError::Close("Remote provided CLTV expiry in seconds instead of block height".to_owned()));
2983                 }
2984
2985                 if self.channel_state & ChannelState::LocalShutdownSent as u32 != 0 {
2986                         if let PendingHTLCStatus::Forward(_) = pending_forward_status {
2987                                 panic!("ChannelManager shouldn't be trying to add a forwardable HTLC after we've started closing");
2988                         }
2989                 }
2990
2991                 // Now update local state:
2992                 self.next_counterparty_htlc_id += 1;
2993                 self.pending_inbound_htlcs.push(InboundHTLCOutput {
2994                         htlc_id: msg.htlc_id,
2995                         amount_msat: msg.amount_msat,
2996                         payment_hash: msg.payment_hash,
2997                         cltv_expiry: msg.cltv_expiry,
2998                         state: InboundHTLCState::RemoteAnnounced(pending_forward_status),
2999                 });
3000                 Ok(())
3001         }
3002
3003         /// Marks an outbound HTLC which we have received update_fail/fulfill/malformed
3004         #[inline]
3005         fn mark_outbound_htlc_removed(&mut self, htlc_id: u64, check_preimage: Option<PaymentPreimage>, fail_reason: Option<HTLCFailReason>) -> Result<&OutboundHTLCOutput, ChannelError> {
3006                 assert!(!(check_preimage.is_some() && fail_reason.is_some()), "cannot fail while we have a preimage");
3007                 for htlc in self.pending_outbound_htlcs.iter_mut() {
3008                         if htlc.htlc_id == htlc_id {
3009                                 let outcome = match check_preimage {
3010                                         None => fail_reason.into(),
3011                                         Some(payment_preimage) => {
3012                                                 let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
3013                                                 if payment_hash != htlc.payment_hash {
3014                                                         return Err(ChannelError::Close(format!("Remote tried to fulfill HTLC ({}) with an incorrect preimage", htlc_id)));
3015                                                 }
3016                                                 OutboundHTLCOutcome::Success(Some(payment_preimage))
3017                                         }
3018                                 };
3019                                 match htlc.state {
3020                                         OutboundHTLCState::LocalAnnounced(_) =>
3021                                                 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) before it had been committed", htlc_id))),
3022                                         OutboundHTLCState::Committed => {
3023                                                 htlc.state = OutboundHTLCState::RemoteRemoved(outcome);
3024                                         },
3025                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) | OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) | OutboundHTLCState::RemoteRemoved(_) =>
3026                                                 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) that they'd already fulfilled/failed", htlc_id))),
3027                                 }
3028                                 return Ok(htlc);
3029                         }
3030                 }
3031                 Err(ChannelError::Close("Remote tried to fulfill/fail an HTLC we couldn't find".to_owned()))
3032         }
3033
3034         pub fn update_fulfill_htlc(&mut self, msg: &msgs::UpdateFulfillHTLC) -> Result<(HTLCSource, u64), ChannelError> {
3035                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3036                         return Err(ChannelError::Close("Got fulfill HTLC message when channel was not in an operational state".to_owned()));
3037                 }
3038                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3039                         return Err(ChannelError::Close("Peer sent update_fulfill_htlc when we needed a channel_reestablish".to_owned()));
3040                 }
3041
3042                 self.mark_outbound_htlc_removed(msg.htlc_id, Some(msg.payment_preimage), None).map(|htlc| (htlc.source.clone(), htlc.amount_msat))
3043         }
3044
3045         pub fn update_fail_htlc(&mut self, msg: &msgs::UpdateFailHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
3046                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3047                         return Err(ChannelError::Close("Got fail HTLC message when channel was not in an operational state".to_owned()));
3048                 }
3049                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3050                         return Err(ChannelError::Close("Peer sent update_fail_htlc when we needed a channel_reestablish".to_owned()));
3051                 }
3052
3053                 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
3054                 Ok(())
3055         }
3056
3057         pub fn update_fail_malformed_htlc(&mut self, msg: &msgs::UpdateFailMalformedHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
3058                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3059                         return Err(ChannelError::Close("Got fail malformed HTLC message when channel was not in an operational state".to_owned()));
3060                 }
3061                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3062                         return Err(ChannelError::Close("Peer sent update_fail_malformed_htlc when we needed a channel_reestablish".to_owned()));
3063                 }
3064
3065                 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
3066                 Ok(())
3067         }
3068
3069         pub fn commitment_signed<L: Deref>(&mut self, msg: &msgs::CommitmentSigned, logger: &L) -> Result<&ChannelMonitorUpdate, ChannelError>
3070                 where L::Target: Logger
3071         {
3072                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3073                         return Err(ChannelError::Close("Got commitment signed message when channel was not in an operational state".to_owned()));
3074                 }
3075                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3076                         return Err(ChannelError::Close("Peer sent commitment_signed when we needed a channel_reestablish".to_owned()));
3077                 }
3078                 if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.last_sent_closing_fee.is_some() {
3079                         return Err(ChannelError::Close("Peer sent commitment_signed after we'd started exchanging closing_signeds".to_owned()));
3080                 }
3081
3082                 let funding_script = self.get_funding_redeemscript();
3083
3084                 let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
3085
3086                 let commitment_stats = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, logger);
3087                 let commitment_txid = {
3088                         let trusted_tx = commitment_stats.tx.trust();
3089                         let bitcoin_tx = trusted_tx.built_transaction();
3090                         let sighash = bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
3091
3092                         log_trace!(logger, "Checking commitment tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}",
3093                                 log_bytes!(msg.signature.serialize_compact()[..]),
3094                                 log_bytes!(self.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&bitcoin_tx.transaction),
3095                                 log_bytes!(sighash[..]), encode::serialize_hex(&funding_script), log_bytes!(self.channel_id()));
3096                         if let Err(_) = self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.counterparty_funding_pubkey()) {
3097                                 return Err(ChannelError::Close("Invalid commitment tx signature from peer".to_owned()));
3098                         }
3099                         bitcoin_tx.txid
3100                 };
3101                 let mut htlcs_cloned: Vec<_> = commitment_stats.htlcs_included.iter().map(|htlc| (htlc.0.clone(), htlc.1.map(|h| h.clone()))).collect();
3102
3103                 // If our counterparty updated the channel fee in this commitment transaction, check that
3104                 // they can actually afford the new fee now.
3105                 let update_fee = if let Some((_, update_state)) = self.pending_update_fee {
3106                         update_state == FeeUpdateState::RemoteAnnounced
3107                 } else { false };
3108                 if update_fee {
3109                         debug_assert!(!self.is_outbound());
3110                         let counterparty_reserve_we_require_msat = self.holder_selected_channel_reserve_satoshis * 1000;
3111                         if commitment_stats.remote_balance_msat < commitment_stats.total_fee_sat * 1000 + counterparty_reserve_we_require_msat {
3112                                 return Err(ChannelError::Close("Funding remote cannot afford proposed new fee".to_owned()));
3113                         }
3114                 }
3115                 #[cfg(any(test, fuzzing))]
3116                 {
3117                         if self.is_outbound() {
3118                                 let projected_commit_tx_info = self.next_local_commitment_tx_fee_info_cached.lock().unwrap().take();
3119                                 *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
3120                                 if let Some(info) = projected_commit_tx_info {
3121                                         let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len()
3122                                                 + self.holding_cell_htlc_updates.len();
3123                                         if info.total_pending_htlcs == total_pending_htlcs
3124                                                 && info.next_holder_htlc_id == self.next_holder_htlc_id
3125                                                 && info.next_counterparty_htlc_id == self.next_counterparty_htlc_id
3126                                                 && info.feerate == self.feerate_per_kw {
3127                                                         assert_eq!(commitment_stats.total_fee_sat, info.fee / 1000);
3128                                                 }
3129                                 }
3130                         }
3131                 }
3132
3133                 if msg.htlc_signatures.len() != commitment_stats.num_nondust_htlcs {
3134                         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)));
3135                 }
3136
3137                 // Up to LDK 0.0.115, HTLC information was required to be duplicated in the
3138                 // `htlcs_and_sigs` vec and in the `holder_commitment_tx` itself, both of which were passed
3139                 // in the `ChannelMonitorUpdate`. In 0.0.115, support for having a separate set of
3140                 // outbound-non-dust-HTLCSources in the `ChannelMonitorUpdate` was added, however for
3141                 // backwards compatibility, we never use it in production. To provide test coverage, here,
3142                 // we randomly decide (in test/fuzzing builds) to use the new vec sometimes.
3143                 #[allow(unused_assignments, unused_mut)]
3144                 let mut separate_nondust_htlc_sources = false;
3145                 #[cfg(all(feature = "std", any(test, fuzzing)))] {
3146                         use core::hash::{BuildHasher, Hasher};
3147                         // Get a random value using the only std API to do so - the DefaultHasher
3148                         let rand_val = std::collections::hash_map::RandomState::new().build_hasher().finish();
3149                         separate_nondust_htlc_sources = rand_val % 2 == 0;
3150                 }
3151
3152                 let mut nondust_htlc_sources = Vec::with_capacity(htlcs_cloned.len());
3153                 let mut htlcs_and_sigs = Vec::with_capacity(htlcs_cloned.len());
3154                 for (idx, (htlc, mut source_opt)) in htlcs_cloned.drain(..).enumerate() {
3155                         if let Some(_) = htlc.transaction_output_index {
3156                                 let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_stats.feerate_per_kw,
3157                                         self.get_counterparty_selected_contest_delay().unwrap(), &htlc, self.opt_anchors(),
3158                                         false, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
3159
3160                                 let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, self.opt_anchors(), &keys);
3161                                 let htlc_sighashtype = if self.opt_anchors() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
3162                                 let htlc_sighash = hash_to_message!(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]);
3163                                 log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}.",
3164                                         log_bytes!(msg.htlc_signatures[idx].serialize_compact()[..]), log_bytes!(keys.countersignatory_htlc_key.serialize()),
3165                                         encode::serialize_hex(&htlc_tx), log_bytes!(htlc_sighash[..]), encode::serialize_hex(&htlc_redeemscript), log_bytes!(self.channel_id()));
3166                                 if let Err(_) = self.secp_ctx.verify_ecdsa(&htlc_sighash, &msg.htlc_signatures[idx], &keys.countersignatory_htlc_key) {
3167                                         return Err(ChannelError::Close("Invalid HTLC tx signature from peer".to_owned()));
3168                                 }
3169                                 if !separate_nondust_htlc_sources {
3170                                         htlcs_and_sigs.push((htlc, Some(msg.htlc_signatures[idx]), source_opt.take()));
3171                                 }
3172                         } else {
3173                                 htlcs_and_sigs.push((htlc, None, source_opt.take()));
3174                         }
3175                         if separate_nondust_htlc_sources {
3176                                 if let Some(source) = source_opt.take() {
3177                                         nondust_htlc_sources.push(source);
3178                                 }
3179                         }
3180                         debug_assert!(source_opt.is_none(), "HTLCSource should have been put somewhere");
3181                 }
3182
3183                 let holder_commitment_tx = HolderCommitmentTransaction::new(
3184                         commitment_stats.tx,
3185                         msg.signature,
3186                         msg.htlc_signatures.clone(),
3187                         &self.get_holder_pubkeys().funding_pubkey,
3188                         self.counterparty_funding_pubkey()
3189                 );
3190
3191                 self.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
3192                         .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
3193
3194                 // Update state now that we've passed all the can-fail calls...
3195                 let mut need_commitment = false;
3196                 if let &mut Some((_, ref mut update_state)) = &mut self.pending_update_fee {
3197                         if *update_state == FeeUpdateState::RemoteAnnounced {
3198                                 *update_state = FeeUpdateState::AwaitingRemoteRevokeToAnnounce;
3199                                 need_commitment = true;
3200                         }
3201                 }
3202
3203                 for htlc in self.pending_inbound_htlcs.iter_mut() {
3204                         let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
3205                                 Some(forward_info.clone())
3206                         } else { None };
3207                         if let Some(forward_info) = new_forward {
3208                                 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToAnnounce due to commitment_signed in channel {}.",
3209                                         log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
3210                                 htlc.state = InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info);
3211                                 need_commitment = true;
3212                         }
3213                 }
3214                 let mut claimed_htlcs = Vec::new();
3215                 for htlc in self.pending_outbound_htlcs.iter_mut() {
3216                         if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
3217                                 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
3218                                         log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
3219                                 // Grab the preimage, if it exists, instead of cloning
3220                                 let mut reason = OutboundHTLCOutcome::Success(None);
3221                                 mem::swap(outcome, &mut reason);
3222                                 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
3223                                         // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
3224                                         // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
3225                                         // have a `Success(None)` reason. In this case we could forget some HTLC
3226                                         // claims, but such an upgrade is unlikely and including claimed HTLCs here
3227                                         // fixes a bug which the user was exposed to on 0.0.104 when they started the
3228                                         // claim anyway.
3229                                         claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
3230                                 }
3231                                 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
3232                                 need_commitment = true;
3233                         }
3234                 }
3235
3236                 self.latest_monitor_update_id += 1;
3237                 let mut monitor_update = ChannelMonitorUpdate {
3238                         update_id: self.latest_monitor_update_id,
3239                         updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
3240                                 commitment_tx: holder_commitment_tx,
3241                                 htlc_outputs: htlcs_and_sigs,
3242                                 claimed_htlcs,
3243                                 nondust_htlc_sources,
3244                         }]
3245                 };
3246
3247                 self.cur_holder_commitment_transaction_number -= 1;
3248                 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
3249                 // build_commitment_no_status_check() next which will reset this to RAAFirst.
3250                 self.resend_order = RAACommitmentOrder::CommitmentFirst;
3251
3252                 if (self.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0 {
3253                         // In case we initially failed monitor updating without requiring a response, we need
3254                         // to make sure the RAA gets sent first.
3255                         self.monitor_pending_revoke_and_ack = true;
3256                         if need_commitment && (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
3257                                 // If we were going to send a commitment_signed after the RAA, go ahead and do all
3258                                 // the corresponding HTLC status updates so that get_last_commitment_update
3259                                 // includes the right HTLCs.
3260                                 self.monitor_pending_commitment_signed = true;
3261                                 let mut additional_update = self.build_commitment_no_status_check(logger);
3262                                 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3263                                 // strictly increasing by one, so decrement it here.
3264                                 self.latest_monitor_update_id = monitor_update.update_id;
3265                                 monitor_update.updates.append(&mut additional_update.updates);
3266                         }
3267                         log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updated HTLC state but awaiting a monitor update resolution to reply.",
3268                                 log_bytes!(self.channel_id));
3269                         self.pending_monitor_updates.push(monitor_update);
3270                         return Ok(self.pending_monitor_updates.last().unwrap());
3271                 }
3272
3273                 let need_commitment_signed = if need_commitment && (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
3274                         // If we're AwaitingRemoteRevoke we can't send a new commitment here, but that's ok -
3275                         // we'll send one right away when we get the revoke_and_ack when we
3276                         // free_holding_cell_htlcs().
3277                         let mut additional_update = self.build_commitment_no_status_check(logger);
3278                         // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3279                         // strictly increasing by one, so decrement it here.
3280                         self.latest_monitor_update_id = monitor_update.update_id;
3281                         monitor_update.updates.append(&mut additional_update.updates);
3282                         true
3283                 } else { false };
3284
3285                 log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updating HTLC state and responding with{} a revoke_and_ack.",
3286                         log_bytes!(self.channel_id()), if need_commitment_signed { " our own commitment_signed and" } else { "" });
3287                 self.pending_monitor_updates.push(monitor_update);
3288                 self.monitor_updating_paused(true, need_commitment_signed, false, Vec::new(), Vec::new(), Vec::new());
3289                 return Ok(self.pending_monitor_updates.last().unwrap());
3290         }
3291
3292         /// Public version of the below, checking relevant preconditions first.
3293         /// If we're not in a state where freeing the holding cell makes sense, this is a no-op and
3294         /// returns `(None, Vec::new())`.
3295         pub fn maybe_free_holding_cell_htlcs<L: Deref>(&mut self, logger: &L) -> (Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
3296                 if self.channel_state >= ChannelState::ChannelReady as u32 &&
3297                    (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) == 0 {
3298                         self.free_holding_cell_htlcs(logger)
3299                 } else { (None, Vec::new()) }
3300         }
3301
3302         /// Frees any pending commitment updates in the holding cell, generating the relevant messages
3303         /// for our counterparty.
3304         fn free_holding_cell_htlcs<L: Deref>(&mut self, logger: &L) -> (Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
3305                 assert_eq!(self.channel_state & ChannelState::MonitorUpdateInProgress as u32, 0);
3306                 if self.holding_cell_htlc_updates.len() != 0 || self.holding_cell_update_fee.is_some() {
3307                         log_trace!(logger, "Freeing holding cell with {} HTLC updates{} in channel {}", self.holding_cell_htlc_updates.len(),
3308                                 if self.holding_cell_update_fee.is_some() { " and a fee update" } else { "" }, log_bytes!(self.channel_id()));
3309
3310                         let mut monitor_update = ChannelMonitorUpdate {
3311                                 update_id: self.latest_monitor_update_id + 1, // We don't increment this yet!
3312                                 updates: Vec::new(),
3313                         };
3314
3315                         let mut htlc_updates = Vec::new();
3316                         mem::swap(&mut htlc_updates, &mut self.holding_cell_htlc_updates);
3317                         let mut update_add_htlcs = Vec::with_capacity(htlc_updates.len());
3318                         let mut update_fulfill_htlcs = Vec::with_capacity(htlc_updates.len());
3319                         let mut update_fail_htlcs = Vec::with_capacity(htlc_updates.len());
3320                         let mut htlcs_to_fail = Vec::new();
3321                         for htlc_update in htlc_updates.drain(..) {
3322                                 // Note that this *can* fail, though it should be due to rather-rare conditions on
3323                                 // fee races with adding too many outputs which push our total payments just over
3324                                 // the limit. In case it's less rare than I anticipate, we may want to revisit
3325                                 // handling this case better and maybe fulfilling some of the HTLCs while attempting
3326                                 // to rebalance channels.
3327                                 match &htlc_update {
3328                                         &HTLCUpdateAwaitingACK::AddHTLC {amount_msat, cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet, ..} => {
3329                                                 match self.send_htlc(amount_msat, *payment_hash, cltv_expiry, source.clone(), onion_routing_packet.clone(), false, logger) {
3330                                                         Ok(update_add_msg_option) => update_add_htlcs.push(update_add_msg_option.unwrap()),
3331                                                         Err(e) => {
3332                                                                 match e {
3333                                                                         ChannelError::Ignore(ref msg) => {
3334                                                                                 log_info!(logger, "Failed to send HTLC with payment_hash {} due to {} in channel {}",
3335                                                                                         log_bytes!(payment_hash.0), msg, log_bytes!(self.channel_id()));
3336                                                                                 // If we fail to send here, then this HTLC should
3337                                                                                 // be failed backwards. Failing to send here
3338                                                                                 // indicates that this HTLC may keep being put back
3339                                                                                 // into the holding cell without ever being
3340                                                                                 // successfully forwarded/failed/fulfilled, causing
3341                                                                                 // our counterparty to eventually close on us.
3342                                                                                 htlcs_to_fail.push((source.clone(), *payment_hash));
3343                                                                         },
3344                                                                         _ => {
3345                                                                                 panic!("Got a non-IgnoreError action trying to send holding cell HTLC");
3346                                                                         },
3347                                                                 }
3348                                                         }
3349                                                 }
3350                                         },
3351                                         &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, htlc_id, .. } => {
3352                                                 // If an HTLC claim was previously added to the holding cell (via
3353                                                 // `get_update_fulfill_htlc`, then generating the claim message itself must
3354                                                 // not fail - any in between attempts to claim the HTLC will have resulted
3355                                                 // in it hitting the holding cell again and we cannot change the state of a
3356                                                 // holding cell HTLC from fulfill to anything else.
3357                                                 let (update_fulfill_msg_option, mut additional_monitor_update) =
3358                                                         if let UpdateFulfillFetch::NewClaim { msg, monitor_update, .. } = self.get_update_fulfill_htlc(htlc_id, *payment_preimage, logger) {
3359                                                                 (msg, monitor_update)
3360                                                         } else { unreachable!() };
3361                                                 update_fulfill_htlcs.push(update_fulfill_msg_option.unwrap());
3362                                                 monitor_update.updates.append(&mut additional_monitor_update.updates);
3363                                         },
3364                                         &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, ref err_packet } => {
3365                                                 match self.fail_htlc(htlc_id, err_packet.clone(), false, logger) {
3366                                                         Ok(update_fail_msg_option) => {
3367                                                                 // If an HTLC failure was previously added to the holding cell (via
3368                                                                 // `queue_fail_htlc`) then generating the fail message itself must
3369                                                                 // not fail - we should never end up in a state where we double-fail
3370                                                                 // an HTLC or fail-then-claim an HTLC as it indicates we didn't wait
3371                                                                 // for a full revocation before failing.
3372                                                                 update_fail_htlcs.push(update_fail_msg_option.unwrap())
3373                                                         },
3374                                                         Err(e) => {
3375                                                                 if let ChannelError::Ignore(_) = e {}
3376                                                                 else {
3377                                                                         panic!("Got a non-IgnoreError action trying to fail holding cell HTLC");
3378                                                                 }
3379                                                         }
3380                                                 }
3381                                         },
3382                                 }
3383                         }
3384                         if update_add_htlcs.is_empty() && update_fulfill_htlcs.is_empty() && update_fail_htlcs.is_empty() && self.holding_cell_update_fee.is_none() {
3385                                 return (None, htlcs_to_fail);
3386                         }
3387                         let update_fee = if let Some(feerate) = self.holding_cell_update_fee.take() {
3388                                 self.send_update_fee(feerate, false, logger)
3389                         } else {
3390                                 None
3391                         };
3392
3393                         let mut additional_update = self.build_commitment_no_status_check(logger);
3394                         // build_commitment_no_status_check and get_update_fulfill_htlc may bump latest_monitor_id
3395                         // but we want them to be strictly increasing by one, so reset it here.
3396                         self.latest_monitor_update_id = monitor_update.update_id;
3397                         monitor_update.updates.append(&mut additional_update.updates);
3398
3399                         log_debug!(logger, "Freeing holding cell in channel {} resulted in {}{} HTLCs added, {} HTLCs fulfilled, and {} HTLCs failed.",
3400                                 log_bytes!(self.channel_id()), if update_fee.is_some() { "a fee update, " } else { "" },
3401                                 update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len());
3402
3403                         self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
3404                         self.pending_monitor_updates.push(monitor_update);
3405                         (Some(self.pending_monitor_updates.last().unwrap()), htlcs_to_fail)
3406                 } else {
3407                         (None, Vec::new())
3408                 }
3409         }
3410
3411         /// Handles receiving a remote's revoke_and_ack. Note that we may return a new
3412         /// commitment_signed message here in case we had pending outbound HTLCs to add which were
3413         /// waiting on this revoke_and_ack. The generation of this new commitment_signed may also fail,
3414         /// generating an appropriate error *after* the channel state has been updated based on the
3415         /// revoke_and_ack message.
3416         pub fn revoke_and_ack<L: Deref>(&mut self, msg: &msgs::RevokeAndACK, logger: &L) -> Result<(Vec<(HTLCSource, PaymentHash)>, &ChannelMonitorUpdate), ChannelError>
3417                 where L::Target: Logger,
3418         {
3419                 if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3420                         return Err(ChannelError::Close("Got revoke/ACK message when channel was not in an operational state".to_owned()));
3421                 }
3422                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3423                         return Err(ChannelError::Close("Peer sent revoke_and_ack when we needed a channel_reestablish".to_owned()));
3424                 }
3425                 if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.last_sent_closing_fee.is_some() {
3426                         return Err(ChannelError::Close("Peer sent revoke_and_ack after we'd started exchanging closing_signeds".to_owned()));
3427                 }
3428
3429                 let secret = secp_check!(SecretKey::from_slice(&msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret".to_owned());
3430
3431                 if let Some(counterparty_prev_commitment_point) = self.counterparty_prev_commitment_point {
3432                         if PublicKey::from_secret_key(&self.secp_ctx, &secret) != counterparty_prev_commitment_point {
3433                                 return Err(ChannelError::Close("Got a revoke commitment secret which didn't correspond to their current pubkey".to_owned()));
3434                         }
3435                 }
3436
3437                 if self.channel_state & ChannelState::AwaitingRemoteRevoke as u32 == 0 {
3438                         // Our counterparty seems to have burned their coins to us (by revoking a state when we
3439                         // haven't given them a new commitment transaction to broadcast). We should probably
3440                         // take advantage of this by updating our channel monitor, sending them an error, and
3441                         // waiting for them to broadcast their latest (now-revoked claim). But, that would be a
3442                         // lot of work, and there's some chance this is all a misunderstanding anyway.
3443                         // We have to do *something*, though, since our signer may get mad at us for otherwise
3444                         // jumping a remote commitment number, so best to just force-close and move on.
3445                         return Err(ChannelError::Close("Received an unexpected revoke_and_ack".to_owned()));
3446                 }
3447
3448                 #[cfg(any(test, fuzzing))]
3449                 {
3450                         *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
3451                         *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
3452                 }
3453
3454                 self.holder_signer.validate_counterparty_revocation(
3455                         self.cur_counterparty_commitment_transaction_number + 1,
3456                         &secret
3457                 ).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
3458
3459                 self.commitment_secrets.provide_secret(self.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
3460                         .map_err(|_| ChannelError::Close("Previous secrets did not match new one".to_owned()))?;
3461                 self.latest_monitor_update_id += 1;
3462                 let mut monitor_update = ChannelMonitorUpdate {
3463                         update_id: self.latest_monitor_update_id,
3464                         updates: vec![ChannelMonitorUpdateStep::CommitmentSecret {
3465                                 idx: self.cur_counterparty_commitment_transaction_number + 1,
3466                                 secret: msg.per_commitment_secret,
3467                         }],
3468                 };
3469
3470                 // Update state now that we've passed all the can-fail calls...
3471                 // (note that we may still fail to generate the new commitment_signed message, but that's
3472                 // OK, we step the channel here and *then* if the new generation fails we can fail the
3473                 // channel based on that, but stepping stuff here should be safe either way.
3474                 self.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32);
3475                 self.counterparty_prev_commitment_point = self.counterparty_cur_commitment_point;
3476                 self.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
3477                 self.cur_counterparty_commitment_transaction_number -= 1;
3478
3479                 if self.announcement_sigs_state == AnnouncementSigsState::Committed {
3480                         self.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
3481                 }
3482
3483                 log_trace!(logger, "Updating HTLCs on receipt of RAA in channel {}...", log_bytes!(self.channel_id()));
3484                 let mut to_forward_infos = Vec::new();
3485                 let mut revoked_htlcs = Vec::new();
3486                 let mut finalized_claimed_htlcs = Vec::new();
3487                 let mut update_fail_htlcs = Vec::new();
3488                 let mut update_fail_malformed_htlcs = Vec::new();
3489                 let mut require_commitment = false;
3490                 let mut value_to_self_msat_diff: i64 = 0;
3491
3492                 {
3493                         // Take references explicitly so that we can hold multiple references to self.
3494                         let pending_inbound_htlcs: &mut Vec<_> = &mut self.pending_inbound_htlcs;
3495                         let pending_outbound_htlcs: &mut Vec<_> = &mut self.pending_outbound_htlcs;
3496
3497                         // We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
3498                         pending_inbound_htlcs.retain(|htlc| {
3499                                 if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
3500                                         log_trace!(logger, " ...removing inbound LocalRemoved {}", log_bytes!(htlc.payment_hash.0));
3501                                         if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
3502                                                 value_to_self_msat_diff += htlc.amount_msat as i64;
3503                                         }
3504                                         false
3505                                 } else { true }
3506                         });
3507                         pending_outbound_htlcs.retain(|htlc| {
3508                                 if let &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) = &htlc.state {
3509                                         log_trace!(logger, " ...removing outbound AwaitingRemovedRemoteRevoke {}", log_bytes!(htlc.payment_hash.0));
3510                                         if let OutboundHTLCOutcome::Failure(reason) = outcome.clone() { // We really want take() here, but, again, non-mut ref :(
3511                                                 revoked_htlcs.push((htlc.source.clone(), htlc.payment_hash, reason));
3512                                         } else {
3513                                                 finalized_claimed_htlcs.push(htlc.source.clone());
3514                                                 // They fulfilled, so we sent them money
3515                                                 value_to_self_msat_diff -= htlc.amount_msat as i64;
3516                                         }
3517                                         false
3518                                 } else { true }
3519                         });
3520                         for htlc in pending_inbound_htlcs.iter_mut() {
3521                                 let swap = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) = &htlc.state {
3522                                         true
3523                                 } else if let &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) = &htlc.state {
3524                                         true
3525                                 } else { false };
3526                                 if swap {
3527                                         let mut state = InboundHTLCState::Committed;
3528                                         mem::swap(&mut state, &mut htlc.state);
3529
3530                                         if let InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info) = state {
3531                                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
3532                                                 htlc.state = InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info);
3533                                                 require_commitment = true;
3534                                         } else if let InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info) = state {
3535                                                 match forward_info {
3536                                                         PendingHTLCStatus::Fail(fail_msg) => {
3537                                                                 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to LocalRemoved due to PendingHTLCStatus indicating failure", log_bytes!(htlc.payment_hash.0));
3538                                                                 require_commitment = true;
3539                                                                 match fail_msg {
3540                                                                         HTLCFailureMsg::Relay(msg) => {
3541                                                                                 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(msg.reason.clone()));
3542                                                                                 update_fail_htlcs.push(msg)
3543                                                                         },
3544                                                                         HTLCFailureMsg::Malformed(msg) => {
3545                                                                                 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed((msg.sha256_of_onion, msg.failure_code)));
3546                                                                                 update_fail_malformed_htlcs.push(msg)
3547                                                                         },
3548                                                                 }
3549                                                         },
3550                                                         PendingHTLCStatus::Forward(forward_info) => {
3551                                                                 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed", log_bytes!(htlc.payment_hash.0));
3552                                                                 to_forward_infos.push((forward_info, htlc.htlc_id));
3553                                                                 htlc.state = InboundHTLCState::Committed;
3554                                                         }
3555                                                 }
3556                                         }
3557                                 }
3558                         }
3559                         for htlc in pending_outbound_htlcs.iter_mut() {
3560                                 if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
3561                                         log_trace!(logger, " ...promoting outbound LocalAnnounced {} to Committed", log_bytes!(htlc.payment_hash.0));
3562                                         htlc.state = OutboundHTLCState::Committed;
3563                                 }
3564                                 if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
3565                                         log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
3566                                         // Grab the preimage, if it exists, instead of cloning
3567                                         let mut reason = OutboundHTLCOutcome::Success(None);
3568                                         mem::swap(outcome, &mut reason);
3569                                         htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
3570                                         require_commitment = true;
3571                                 }
3572                         }
3573                 }
3574                 self.value_to_self_msat = (self.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
3575
3576                 if let Some((feerate, update_state)) = self.pending_update_fee {
3577                         match update_state {
3578                                 FeeUpdateState::Outbound => {
3579                                         debug_assert!(self.is_outbound());
3580                                         log_trace!(logger, " ...promoting outbound fee update {} to Committed", feerate);
3581                                         self.feerate_per_kw = feerate;
3582                                         self.pending_update_fee = None;
3583                                 },
3584                                 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.is_outbound()); },
3585                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => {
3586                                         debug_assert!(!self.is_outbound());
3587                                         log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
3588                                         require_commitment = true;
3589                                         self.feerate_per_kw = feerate;
3590                                         self.pending_update_fee = None;
3591                                 },
3592                         }
3593                 }
3594
3595                 if (self.channel_state & ChannelState::MonitorUpdateInProgress as u32) == ChannelState::MonitorUpdateInProgress as u32 {
3596                         // We can't actually generate a new commitment transaction (incl by freeing holding
3597                         // cells) while we can't update the monitor, so we just return what we have.
3598                         if require_commitment {
3599                                 self.monitor_pending_commitment_signed = true;
3600                                 // When the monitor updating is restored we'll call get_last_commitment_update(),
3601                                 // which does not update state, but we're definitely now awaiting a remote revoke
3602                                 // before we can step forward any more, so set it here.
3603                                 let mut additional_update = self.build_commitment_no_status_check(logger);
3604                                 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3605                                 // strictly increasing by one, so decrement it here.
3606                                 self.latest_monitor_update_id = monitor_update.update_id;
3607                                 monitor_update.updates.append(&mut additional_update.updates);
3608                         }
3609                         self.monitor_pending_forwards.append(&mut to_forward_infos);
3610                         self.monitor_pending_failures.append(&mut revoked_htlcs);
3611                         self.monitor_pending_finalized_fulfills.append(&mut finalized_claimed_htlcs);
3612                         log_debug!(logger, "Received a valid revoke_and_ack for channel {} but awaiting a monitor update resolution to reply.", log_bytes!(self.channel_id()));
3613                         self.pending_monitor_updates.push(monitor_update);
3614                         return Ok((Vec::new(), self.pending_monitor_updates.last().unwrap()));
3615                 }
3616
3617                 match self.free_holding_cell_htlcs(logger) {
3618                         (Some(_), htlcs_to_fail) => {
3619                                 let mut additional_update = self.pending_monitor_updates.pop().unwrap();
3620                                 // free_holding_cell_htlcs may bump latest_monitor_id multiple times but we want them to be
3621                                 // strictly increasing by one, so decrement it here.
3622                                 self.latest_monitor_update_id = monitor_update.update_id;
3623                                 monitor_update.updates.append(&mut additional_update.updates);
3624
3625                                 self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3626                                 self.pending_monitor_updates.push(monitor_update);
3627                                 Ok((htlcs_to_fail, self.pending_monitor_updates.last().unwrap()))
3628                         },
3629                         (None, htlcs_to_fail) => {
3630                                 if require_commitment {
3631                                         let mut additional_update = self.build_commitment_no_status_check(logger);
3632
3633                                         // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3634                                         // strictly increasing by one, so decrement it here.
3635                                         self.latest_monitor_update_id = monitor_update.update_id;
3636                                         monitor_update.updates.append(&mut additional_update.updates);
3637
3638                                         log_debug!(logger, "Received a valid revoke_and_ack for channel {}. Responding with a commitment update with {} HTLCs failed.",
3639                                                 log_bytes!(self.channel_id()), update_fail_htlcs.len() + update_fail_malformed_htlcs.len());
3640                                         self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3641                                         self.pending_monitor_updates.push(monitor_update);
3642                                         Ok((htlcs_to_fail, self.pending_monitor_updates.last().unwrap()))
3643                                 } else {
3644                                         log_debug!(logger, "Received a valid revoke_and_ack for channel {} with no reply necessary.", log_bytes!(self.channel_id()));
3645                                         self.monitor_updating_paused(false, false, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3646                                         self.pending_monitor_updates.push(monitor_update);
3647                                         Ok((htlcs_to_fail, self.pending_monitor_updates.last().unwrap()))
3648                                 }
3649                         }
3650                 }
3651         }
3652
3653         /// Queues up an outbound update fee by placing it in the holding cell. You should call
3654         /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
3655         /// commitment update.
3656         pub fn queue_update_fee<L: Deref>(&mut self, feerate_per_kw: u32, logger: &L) where L::Target: Logger {
3657                 let msg_opt = self.send_update_fee(feerate_per_kw, true, logger);
3658                 assert!(msg_opt.is_none(), "We forced holding cell?");
3659         }
3660
3661         /// Adds a pending update to this channel. See the doc for send_htlc for
3662         /// further details on the optionness of the return value.
3663         /// If our balance is too low to cover the cost of the next commitment transaction at the
3664         /// new feerate, the update is cancelled.
3665         ///
3666         /// You MUST call [`Self::send_commitment_no_state_update`] prior to any other calls on this
3667         /// [`Channel`] if `force_holding_cell` is false.
3668         fn send_update_fee<L: Deref>(&mut self, feerate_per_kw: u32, mut force_holding_cell: bool, logger: &L) -> Option<msgs::UpdateFee> where L::Target: Logger {
3669                 if !self.is_outbound() {
3670                         panic!("Cannot send fee from inbound channel");
3671                 }
3672                 if !self.is_usable() {
3673                         panic!("Cannot update fee until channel is fully established and we haven't started shutting down");
3674                 }
3675                 if !self.is_live() {
3676                         panic!("Cannot update fee while peer is disconnected/we're awaiting a monitor update (ChannelManager should have caught this)");
3677                 }
3678
3679                 // Before proposing a feerate update, check that we can actually afford the new fee.
3680                 let inbound_stats = self.get_inbound_pending_htlc_stats(Some(feerate_per_kw));
3681                 let outbound_stats = self.get_outbound_pending_htlc_stats(Some(feerate_per_kw));
3682                 let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
3683                 let commitment_stats = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, true, logger);
3684                 let buffer_fee_msat = Channel::<Signer>::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.opt_anchors()) * 1000;
3685                 let holder_balance_msat = commitment_stats.local_balance_msat - outbound_stats.holding_cell_msat;
3686                 if holder_balance_msat < buffer_fee_msat  + self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 {
3687                         //TODO: auto-close after a number of failures?
3688                         log_debug!(logger, "Cannot afford to send new feerate at {}", feerate_per_kw);
3689                         return None;
3690                 }
3691
3692                 // Note, we evaluate pending htlc "preemptive" trimmed-to-dust threshold at the proposed `feerate_per_kw`.
3693                 let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
3694                 let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
3695                 if holder_tx_dust_exposure > self.get_max_dust_htlc_exposure_msat() {
3696                         log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
3697                         return None;
3698                 }
3699                 if counterparty_tx_dust_exposure > self.get_max_dust_htlc_exposure_msat() {
3700                         log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
3701                         return None;
3702                 }
3703
3704                 if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
3705                         force_holding_cell = true;
3706                 }
3707
3708                 if force_holding_cell {
3709                         self.holding_cell_update_fee = Some(feerate_per_kw);
3710                         return None;
3711                 }
3712
3713                 debug_assert!(self.pending_update_fee.is_none());
3714                 self.pending_update_fee = Some((feerate_per_kw, FeeUpdateState::Outbound));
3715
3716                 Some(msgs::UpdateFee {
3717                         channel_id: self.channel_id,
3718                         feerate_per_kw,
3719                 })
3720         }
3721
3722         /// Removes any uncommitted inbound HTLCs and resets the state of uncommitted outbound HTLC
3723         /// updates, to be used on peer disconnection. After this, update_*_htlc messages need to be
3724         /// resent.
3725         /// No further message handling calls may be made until a channel_reestablish dance has
3726         /// completed.
3727         pub fn remove_uncommitted_htlcs_and_mark_paused<L: Deref>(&mut self, logger: &L)  where L::Target: Logger {
3728                 assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
3729                 if self.channel_state < ChannelState::FundingSent as u32 {
3730                         self.channel_state = ChannelState::ShutdownComplete as u32;
3731                         return;
3732                 }
3733
3734                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == (ChannelState::PeerDisconnected as u32) {
3735                         // While the below code should be idempotent, it's simpler to just return early, as
3736                         // redundant disconnect events can fire, though they should be rare.
3737                         return;
3738                 }
3739
3740                 if self.announcement_sigs_state == AnnouncementSigsState::MessageSent || self.announcement_sigs_state == AnnouncementSigsState::Committed {
3741                         self.announcement_sigs_state = AnnouncementSigsState::NotSent;
3742                 }
3743
3744                 // Upon reconnect we have to start the closing_signed dance over, but shutdown messages
3745                 // will be retransmitted.
3746                 self.last_sent_closing_fee = None;
3747                 self.pending_counterparty_closing_signed = None;
3748                 self.closing_fee_limits = None;
3749
3750                 let mut inbound_drop_count = 0;
3751                 self.pending_inbound_htlcs.retain(|htlc| {
3752                         match htlc.state {
3753                                 InboundHTLCState::RemoteAnnounced(_) => {
3754                                         // They sent us an update_add_htlc but we never got the commitment_signed.
3755                                         // We'll tell them what commitment_signed we're expecting next and they'll drop
3756                                         // this HTLC accordingly
3757                                         inbound_drop_count += 1;
3758                                         false
3759                                 },
3760                                 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_)|InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => {
3761                                         // We received a commitment_signed updating this HTLC and (at least hopefully)
3762                                         // sent a revoke_and_ack (which we can re-transmit) and have heard nothing
3763                                         // in response to it yet, so don't touch it.
3764                                         true
3765                                 },
3766                                 InboundHTLCState::Committed => true,
3767                                 InboundHTLCState::LocalRemoved(_) => {
3768                                         // We (hopefully) sent a commitment_signed updating this HTLC (which we can
3769                                         // re-transmit if needed) and they may have even sent a revoke_and_ack back
3770                                         // (that we missed). Keep this around for now and if they tell us they missed
3771                                         // the commitment_signed we can re-transmit the update then.
3772                                         true
3773                                 },
3774                         }
3775                 });
3776                 self.next_counterparty_htlc_id -= inbound_drop_count;
3777
3778                 if let Some((_, update_state)) = self.pending_update_fee {
3779                         if update_state == FeeUpdateState::RemoteAnnounced {
3780                                 debug_assert!(!self.is_outbound());
3781                                 self.pending_update_fee = None;
3782                         }
3783                 }
3784
3785                 for htlc in self.pending_outbound_htlcs.iter_mut() {
3786                         if let OutboundHTLCState::RemoteRemoved(_) = htlc.state {
3787                                 // They sent us an update to remove this but haven't yet sent the corresponding
3788                                 // commitment_signed, we need to move it back to Committed and they can re-send
3789                                 // the update upon reconnection.
3790                                 htlc.state = OutboundHTLCState::Committed;
3791                         }
3792                 }
3793
3794                 self.channel_state |= ChannelState::PeerDisconnected as u32;
3795                 log_trace!(logger, "Peer disconnection resulted in {} remote-announced HTLC drops on channel {}", inbound_drop_count, log_bytes!(self.channel_id()));
3796         }
3797
3798         /// Indicates that a ChannelMonitor update is in progress and has not yet been fully persisted.
3799         /// This must be called before we return the [`ChannelMonitorUpdate`] back to the
3800         /// [`ChannelManager`], which will call [`Self::monitor_updating_restored`] once the monitor
3801         /// update completes (potentially immediately).
3802         /// The messages which were generated with the monitor update must *not* have been sent to the
3803         /// remote end, and must instead have been dropped. They will be regenerated when
3804         /// [`Self::monitor_updating_restored`] is called.
3805         ///
3806         /// [`ChannelManager`]: super::channelmanager::ChannelManager
3807         /// [`chain::Watch`]: crate::chain::Watch
3808         /// [`ChannelMonitorUpdateStatus::InProgress`]: crate::chain::ChannelMonitorUpdateStatus::InProgress
3809         fn monitor_updating_paused(&mut self, resend_raa: bool, resend_commitment: bool,
3810                 resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
3811                 mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
3812                 mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
3813         ) {
3814                 self.monitor_pending_revoke_and_ack |= resend_raa;
3815                 self.monitor_pending_commitment_signed |= resend_commitment;
3816                 self.monitor_pending_channel_ready |= resend_channel_ready;
3817                 self.monitor_pending_forwards.append(&mut pending_forwards);
3818                 self.monitor_pending_failures.append(&mut pending_fails);
3819                 self.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
3820                 self.channel_state |= ChannelState::MonitorUpdateInProgress as u32;
3821         }
3822
3823         /// Indicates that the latest ChannelMonitor update has been committed by the client
3824         /// successfully and we should restore normal operation. Returns messages which should be sent
3825         /// to the remote side.
3826         pub fn monitor_updating_restored<L: Deref, NS: Deref>(
3827                 &mut self, logger: &L, node_signer: &NS, genesis_block_hash: BlockHash,
3828                 user_config: &UserConfig, best_block_height: u32
3829         ) -> MonitorRestoreUpdates
3830         where
3831                 L::Target: Logger,
3832                 NS::Target: NodeSigner
3833         {
3834                 assert_eq!(self.channel_state & ChannelState::MonitorUpdateInProgress as u32, ChannelState::MonitorUpdateInProgress as u32);
3835                 self.channel_state &= !(ChannelState::MonitorUpdateInProgress as u32);
3836                 self.pending_monitor_updates.clear();
3837
3838                 // If we're past (or at) the FundingSent stage on an outbound channel, try to
3839                 // (re-)broadcast the funding transaction as we may have declined to broadcast it when we
3840                 // first received the funding_signed.
3841                 let mut funding_broadcastable =
3842                         if self.is_outbound() && self.channel_state & !MULTI_STATE_FLAGS >= ChannelState::FundingSent as u32 {
3843                                 self.funding_transaction.take()
3844                         } else { None };
3845                 // That said, if the funding transaction is already confirmed (ie we're active with a
3846                 // minimum_depth over 0) don't bother re-broadcasting the confirmed funding tx.
3847                 if self.channel_state & !MULTI_STATE_FLAGS >= ChannelState::ChannelReady as u32 && self.minimum_depth != Some(0) {
3848                         funding_broadcastable = None;
3849                 }
3850
3851                 // We will never broadcast the funding transaction when we're in MonitorUpdateInProgress
3852                 // (and we assume the user never directly broadcasts the funding transaction and waits for
3853                 // us to do it). Thus, we can only ever hit monitor_pending_channel_ready when we're
3854                 // * an inbound channel that failed to persist the monitor on funding_created and we got
3855                 //   the funding transaction confirmed before the monitor was persisted, or
3856                 // * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
3857                 let channel_ready = if self.monitor_pending_channel_ready {
3858                         assert!(!self.is_outbound() || self.minimum_depth == Some(0),
3859                                 "Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
3860                         self.monitor_pending_channel_ready = false;
3861                         let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
3862                         Some(msgs::ChannelReady {
3863                                 channel_id: self.channel_id(),
3864                                 next_per_commitment_point,
3865                                 short_channel_id_alias: Some(self.outbound_scid_alias),
3866                         })
3867                 } else { None };
3868
3869                 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block_height, logger);
3870
3871                 let mut accepted_htlcs = Vec::new();
3872                 mem::swap(&mut accepted_htlcs, &mut self.monitor_pending_forwards);
3873                 let mut failed_htlcs = Vec::new();
3874                 mem::swap(&mut failed_htlcs, &mut self.monitor_pending_failures);
3875                 let mut finalized_claimed_htlcs = Vec::new();
3876                 mem::swap(&mut finalized_claimed_htlcs, &mut self.monitor_pending_finalized_fulfills);
3877
3878                 if self.channel_state & (ChannelState::PeerDisconnected as u32) != 0 {
3879                         self.monitor_pending_revoke_and_ack = false;
3880                         self.monitor_pending_commitment_signed = false;
3881                         return MonitorRestoreUpdates {
3882                                 raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
3883                                 accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
3884                         };
3885                 }
3886
3887                 let raa = if self.monitor_pending_revoke_and_ack {
3888                         Some(self.get_last_revoke_and_ack())
3889                 } else { None };
3890                 let commitment_update = if self.monitor_pending_commitment_signed {
3891                         Some(self.get_last_commitment_update(logger))
3892                 } else { None };
3893
3894                 self.monitor_pending_revoke_and_ack = false;
3895                 self.monitor_pending_commitment_signed = false;
3896                 let order = self.resend_order.clone();
3897                 log_debug!(logger, "Restored monitor updating in channel {} resulting in {}{} commitment update and {} RAA, with {} first",
3898                         log_bytes!(self.channel_id()), if funding_broadcastable.is_some() { "a funding broadcastable, " } else { "" },
3899                         if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
3900                         match order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
3901                 MonitorRestoreUpdates {
3902                         raa, commitment_update, order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
3903                 }
3904         }
3905
3906         pub fn update_fee<F: Deref, L: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::UpdateFee, logger: &L) -> Result<(), ChannelError>
3907                 where F::Target: FeeEstimator, L::Target: Logger
3908         {
3909                 if self.is_outbound() {
3910                         return Err(ChannelError::Close("Non-funding remote tried to update channel fee".to_owned()));
3911                 }
3912                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3913                         return Err(ChannelError::Close("Peer sent update_fee when we needed a channel_reestablish".to_owned()));
3914                 }
3915                 Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, Some(self.feerate_per_kw), logger)?;
3916                 let feerate_over_dust_buffer = msg.feerate_per_kw > self.get_dust_buffer_feerate(None);
3917
3918                 self.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
3919                 self.update_time_counter += 1;
3920                 // If the feerate has increased over the previous dust buffer (note that
3921                 // `get_dust_buffer_feerate` considers the `pending_update_fee` status), check that we
3922                 // won't be pushed over our dust exposure limit by the feerate increase.
3923                 if feerate_over_dust_buffer {
3924                         let inbound_stats = self.get_inbound_pending_htlc_stats(None);
3925                         let outbound_stats = self.get_outbound_pending_htlc_stats(None);
3926                         let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
3927                         let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
3928                         if holder_tx_dust_exposure > self.get_max_dust_htlc_exposure_msat() {
3929                                 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)",
3930                                         msg.feerate_per_kw, holder_tx_dust_exposure)));
3931                         }
3932                         if counterparty_tx_dust_exposure > self.get_max_dust_htlc_exposure_msat() {
3933                                 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)",
3934                                         msg.feerate_per_kw, counterparty_tx_dust_exposure)));
3935                         }
3936                 }
3937                 Ok(())
3938         }
3939
3940         fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
3941                 let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
3942                 let per_commitment_secret = self.holder_signer.release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
3943                 msgs::RevokeAndACK {
3944                         channel_id: self.channel_id,
3945                         per_commitment_secret,
3946                         next_per_commitment_point,
3947                         #[cfg(taproot)]
3948                         next_local_nonce: None,
3949                 }
3950         }
3951
3952         fn get_last_commitment_update<L: Deref>(&self, logger: &L) -> msgs::CommitmentUpdate where L::Target: Logger {
3953                 let mut update_add_htlcs = Vec::new();
3954                 let mut update_fulfill_htlcs = Vec::new();
3955                 let mut update_fail_htlcs = Vec::new();
3956                 let mut update_fail_malformed_htlcs = Vec::new();
3957
3958                 for htlc in self.pending_outbound_htlcs.iter() {
3959                         if let &OutboundHTLCState::LocalAnnounced(ref onion_packet) = &htlc.state {
3960                                 update_add_htlcs.push(msgs::UpdateAddHTLC {
3961                                         channel_id: self.channel_id(),
3962                                         htlc_id: htlc.htlc_id,
3963                                         amount_msat: htlc.amount_msat,
3964                                         payment_hash: htlc.payment_hash,
3965                                         cltv_expiry: htlc.cltv_expiry,
3966                                         onion_routing_packet: (**onion_packet).clone(),
3967                                 });
3968                         }
3969                 }
3970
3971                 for htlc in self.pending_inbound_htlcs.iter() {
3972                         if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
3973                                 match reason {
3974                                         &InboundHTLCRemovalReason::FailRelay(ref err_packet) => {
3975                                                 update_fail_htlcs.push(msgs::UpdateFailHTLC {
3976                                                         channel_id: self.channel_id(),
3977                                                         htlc_id: htlc.htlc_id,
3978                                                         reason: err_packet.clone()
3979                                                 });
3980                                         },
3981                                         &InboundHTLCRemovalReason::FailMalformed((ref sha256_of_onion, ref failure_code)) => {
3982                                                 update_fail_malformed_htlcs.push(msgs::UpdateFailMalformedHTLC {
3983                                                         channel_id: self.channel_id(),
3984                                                         htlc_id: htlc.htlc_id,
3985                                                         sha256_of_onion: sha256_of_onion.clone(),
3986                                                         failure_code: failure_code.clone(),
3987                                                 });
3988                                         },
3989                                         &InboundHTLCRemovalReason::Fulfill(ref payment_preimage) => {
3990                                                 update_fulfill_htlcs.push(msgs::UpdateFulfillHTLC {
3991                                                         channel_id: self.channel_id(),
3992                                                         htlc_id: htlc.htlc_id,
3993                                                         payment_preimage: payment_preimage.clone(),
3994                                                 });
3995                                         },
3996                                 }
3997                         }
3998                 }
3999
4000                 let update_fee = if self.is_outbound() && self.pending_update_fee.is_some() {
4001                         Some(msgs::UpdateFee {
4002                                 channel_id: self.channel_id(),
4003                                 feerate_per_kw: self.pending_update_fee.unwrap().0,
4004                         })
4005                 } else { None };
4006
4007                 log_trace!(logger, "Regenerated latest commitment update in channel {} with{} {} update_adds, {} update_fulfills, {} update_fails, and {} update_fail_malformeds",
4008                                 log_bytes!(self.channel_id()), if update_fee.is_some() { " update_fee," } else { "" },
4009                                 update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len(), update_fail_malformed_htlcs.len());
4010                 msgs::CommitmentUpdate {
4011                         update_add_htlcs, update_fulfill_htlcs, update_fail_htlcs, update_fail_malformed_htlcs, update_fee,
4012                         commitment_signed: self.send_commitment_no_state_update(logger).expect("It looks like we failed to re-generate a commitment_signed we had previously sent?").0,
4013                 }
4014         }
4015
4016         /// May panic if some calls other than message-handling calls (which will all Err immediately)
4017         /// have been called between remove_uncommitted_htlcs_and_mark_paused and this call.
4018         ///
4019         /// Some links printed in log lines are included here to check them during build (when run with
4020         /// `cargo doc --document-private-items`):
4021         /// [`super::channelmanager::ChannelManager::force_close_without_broadcasting_txn`] and
4022         /// [`super::channelmanager::ChannelManager::force_close_all_channels_without_broadcasting_txn`].
4023         pub fn channel_reestablish<L: Deref, NS: Deref>(
4024                 &mut self, msg: &msgs::ChannelReestablish, logger: &L, node_signer: &NS,
4025                 genesis_block_hash: BlockHash, user_config: &UserConfig, best_block: &BestBlock
4026         ) -> Result<ReestablishResponses, ChannelError>
4027         where
4028                 L::Target: Logger,
4029                 NS::Target: NodeSigner
4030         {
4031                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
4032                         // While BOLT 2 doesn't indicate explicitly we should error this channel here, it
4033                         // almost certainly indicates we are going to end up out-of-sync in some way, so we
4034                         // just close here instead of trying to recover.
4035                         return Err(ChannelError::Close("Peer sent a loose channel_reestablish not after reconnect".to_owned()));
4036                 }
4037
4038                 if msg.next_local_commitment_number >= INITIAL_COMMITMENT_NUMBER || msg.next_remote_commitment_number >= INITIAL_COMMITMENT_NUMBER ||
4039                         msg.next_local_commitment_number == 0 {
4040                         return Err(ChannelError::Close("Peer sent a garbage channel_reestablish".to_owned()));
4041                 }
4042
4043                 if msg.next_remote_commitment_number > 0 {
4044                         match msg.data_loss_protect {
4045                                 OptionalField::Present(ref data_loss) => {
4046                                         let expected_point = self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
4047                                         let given_secret = SecretKey::from_slice(&data_loss.your_last_per_commitment_secret)
4048                                                 .map_err(|_| ChannelError::Close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
4049                                         if expected_point != PublicKey::from_secret_key(&self.secp_ctx, &given_secret) {
4050                                                 return Err(ChannelError::Close("Peer sent a garbage channel_reestablish with secret key not matching the commitment height provided".to_owned()));
4051                                         }
4052                                         if msg.next_remote_commitment_number > INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number {
4053                                                 macro_rules! log_and_panic {
4054                                                         ($err_msg: expr) => {
4055                                                                 log_error!(logger, $err_msg, log_bytes!(self.channel_id), log_pubkey!(self.counterparty_node_id));
4056                                                                 panic!($err_msg, log_bytes!(self.channel_id), log_pubkey!(self.counterparty_node_id));
4057                                                         }
4058                                                 }
4059                                                 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\
4060                                                         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\
4061                                                         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\
4062                                                         If you have restored from an old backup and wish to force-close channels and return to operation, you should start up, call\n\
4063                                                         ChannelManager::force_close_without_broadcasting_txn on channel {} with counterparty {} or\n\
4064                                                         ChannelManager::force_close_all_channels_without_broadcasting_txn, then reconnect to peer(s).\n\
4065                                                         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\
4066                                                         See https://github.com/lightningdevkit/rust-lightning/issues/1565 for more info.");
4067                                         }
4068                                 },
4069                                 OptionalField::Absent => {}
4070                         }
4071                 }
4072
4073                 // Before we change the state of the channel, we check if the peer is sending a very old
4074                 // commitment transaction number, if yes we send a warning message.
4075                 let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number - 1;
4076                 if  msg.next_remote_commitment_number + 1 < our_commitment_transaction {
4077                         return Err(
4078                                 ChannelError::Warn(format!("Peer attempted to reestablish channel with a very old local commitment transaction: {} (received) vs {} (expected)", msg.next_remote_commitment_number, our_commitment_transaction))
4079                         );
4080                 }
4081
4082                 // Go ahead and unmark PeerDisconnected as various calls we may make check for it (and all
4083                 // remaining cases either succeed or ErrorMessage-fail).
4084                 self.channel_state &= !(ChannelState::PeerDisconnected as u32);
4085
4086                 let shutdown_msg = if self.channel_state & (ChannelState::LocalShutdownSent as u32) != 0 {
4087                         assert!(self.shutdown_scriptpubkey.is_some());
4088                         Some(msgs::Shutdown {
4089                                 channel_id: self.channel_id,
4090                                 scriptpubkey: self.get_closing_scriptpubkey(),
4091                         })
4092                 } else { None };
4093
4094                 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block.height(), logger);
4095
4096                 if self.channel_state & (ChannelState::FundingSent as u32) == ChannelState::FundingSent as u32 {
4097                         // If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
4098                         if self.channel_state & (ChannelState::OurChannelReady as u32) == 0 ||
4099                                         self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
4100                                 if msg.next_remote_commitment_number != 0 {
4101                                         return Err(ChannelError::Close("Peer claimed they saw a revoke_and_ack but we haven't sent channel_ready yet".to_owned()));
4102                                 }
4103                                 // Short circuit the whole handler as there is nothing we can resend them
4104                                 return Ok(ReestablishResponses {
4105                                         channel_ready: None,
4106                                         raa: None, commitment_update: None,
4107                                         order: RAACommitmentOrder::CommitmentFirst,
4108                                         shutdown_msg, announcement_sigs,
4109                                 });
4110                         }
4111
4112                         // We have OurChannelReady set!
4113                         let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
4114                         return Ok(ReestablishResponses {
4115                                 channel_ready: Some(msgs::ChannelReady {
4116                                         channel_id: self.channel_id(),
4117                                         next_per_commitment_point,
4118                                         short_channel_id_alias: Some(self.outbound_scid_alias),
4119                                 }),
4120                                 raa: None, commitment_update: None,
4121                                 order: RAACommitmentOrder::CommitmentFirst,
4122                                 shutdown_msg, announcement_sigs,
4123                         });
4124                 }
4125
4126                 let required_revoke = if msg.next_remote_commitment_number + 1 == INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number {
4127                         // Remote isn't waiting on any RevokeAndACK from us!
4128                         // Note that if we need to repeat our ChannelReady we'll do that in the next if block.
4129                         None
4130                 } else if msg.next_remote_commitment_number + 1 == (INITIAL_COMMITMENT_NUMBER - 1) - self.cur_holder_commitment_transaction_number {
4131                         if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
4132                                 self.monitor_pending_revoke_and_ack = true;
4133                                 None
4134                         } else {
4135                                 Some(self.get_last_revoke_and_ack())
4136                         }
4137                 } else {
4138                         return Err(ChannelError::Close("Peer attempted to reestablish channel with a very old local commitment transaction".to_owned()));
4139                 };
4140
4141                 // We increment cur_counterparty_commitment_transaction_number only upon receipt of
4142                 // revoke_and_ack, not on sending commitment_signed, so we add one if have
4143                 // AwaitingRemoteRevoke set, which indicates we sent a commitment_signed but haven't gotten
4144                 // the corresponding revoke_and_ack back yet.
4145                 let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.cur_counterparty_commitment_transaction_number + if (self.channel_state & ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 };
4146
4147                 let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
4148                         // We should never have to worry about MonitorUpdateInProgress resending ChannelReady
4149                         let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
4150                         Some(msgs::ChannelReady {
4151                                 channel_id: self.channel_id(),
4152                                 next_per_commitment_point,
4153                                 short_channel_id_alias: Some(self.outbound_scid_alias),
4154                         })
4155                 } else { None };
4156
4157                 if msg.next_local_commitment_number == next_counterparty_commitment_number {
4158                         if required_revoke.is_some() {
4159                                 log_debug!(logger, "Reconnected channel {} with only lost outbound RAA", log_bytes!(self.channel_id()));
4160                         } else {
4161                                 log_debug!(logger, "Reconnected channel {} with no loss", log_bytes!(self.channel_id()));
4162                         }
4163
4164                         Ok(ReestablishResponses {
4165                                 channel_ready, shutdown_msg, announcement_sigs,
4166                                 raa: required_revoke,
4167                                 commitment_update: None,
4168                                 order: self.resend_order.clone(),
4169                         })
4170                 } else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
4171                         if required_revoke.is_some() {
4172                                 log_debug!(logger, "Reconnected channel {} with lost outbound RAA and lost remote commitment tx", log_bytes!(self.channel_id()));
4173                         } else {
4174                                 log_debug!(logger, "Reconnected channel {} with only lost remote commitment tx", log_bytes!(self.channel_id()));
4175                         }
4176
4177                         if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
4178                                 self.monitor_pending_commitment_signed = true;
4179                                 Ok(ReestablishResponses {
4180                                         channel_ready, shutdown_msg, announcement_sigs,
4181                                         commitment_update: None, raa: None,
4182                                         order: self.resend_order.clone(),
4183                                 })
4184                         } else {
4185                                 Ok(ReestablishResponses {
4186                                         channel_ready, shutdown_msg, announcement_sigs,
4187                                         raa: required_revoke,
4188                                         commitment_update: Some(self.get_last_commitment_update(logger)),
4189                                         order: self.resend_order.clone(),
4190                                 })
4191                         }
4192                 } else {
4193                         Err(ChannelError::Close("Peer attempted to reestablish channel with a very old remote commitment transaction".to_owned()))
4194                 }
4195         }
4196
4197         /// Calculates and returns our minimum and maximum closing transaction fee amounts, in whole
4198         /// satoshis. The amounts remain consistent unless a peer disconnects/reconnects or we restart,
4199         /// at which point they will be recalculated.
4200         fn calculate_closing_fee_limits<F: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>)
4201                 -> (u64, u64)
4202                 where F::Target: FeeEstimator
4203         {
4204                 if let Some((min, max)) = self.closing_fee_limits { return (min, max); }
4205
4206                 // Propose a range from our current Background feerate to our Normal feerate plus our
4207                 // force_close_avoidance_max_fee_satoshis.
4208                 // If we fail to come to consensus, we'll have to force-close.
4209                 let mut proposed_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Background);
4210                 let normal_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Normal);
4211                 let mut proposed_max_feerate = if self.is_outbound() { normal_feerate } else { u32::max_value() };
4212
4213                 // The spec requires that (when the channel does not have anchors) we only send absolute
4214                 // channel fees no greater than the absolute channel fee on the current commitment
4215                 // transaction. It's unclear *which* commitment transaction this refers to, and there isn't
4216                 // very good reason to apply such a limit in any case. We don't bother doing so, risking
4217                 // some force-closure by old nodes, but we wanted to close the channel anyway.
4218
4219                 if let Some(target_feerate) = self.target_closing_feerate_sats_per_kw {
4220                         let min_feerate = if self.is_outbound() { target_feerate } else { cmp::min(self.feerate_per_kw, target_feerate) };
4221                         proposed_feerate = cmp::max(proposed_feerate, min_feerate);
4222                         proposed_max_feerate = cmp::max(proposed_max_feerate, min_feerate);
4223                 }
4224
4225                 // Note that technically we could end up with a lower minimum fee if one sides' balance is
4226                 // below our dust limit, causing the output to disappear. We don't bother handling this
4227                 // case, however, as this should only happen if a channel is closed before any (material)
4228                 // payments have been made on it. This may cause slight fee overpayment and/or failure to
4229                 // come to consensus with our counterparty on appropriate fees, however it should be a
4230                 // relatively rare case. We can revisit this later, though note that in order to determine
4231                 // if the funders' output is dust we have to know the absolute fee we're going to use.
4232                 let tx_weight = self.get_closing_transaction_weight(Some(&self.get_closing_scriptpubkey()), Some(self.counterparty_shutdown_scriptpubkey.as_ref().unwrap()));
4233                 let proposed_total_fee_satoshis = proposed_feerate as u64 * tx_weight / 1000;
4234                 let proposed_max_total_fee_satoshis = if self.is_outbound() {
4235                                 // We always add force_close_avoidance_max_fee_satoshis to our normal
4236                                 // feerate-calculated fee, but allow the max to be overridden if we're using a
4237                                 // target feerate-calculated fee.
4238                                 cmp::max(normal_feerate as u64 * tx_weight / 1000 + self.config.options.force_close_avoidance_max_fee_satoshis,
4239                                         proposed_max_feerate as u64 * tx_weight / 1000)
4240                         } else {
4241                                 self.channel_value_satoshis - (self.value_to_self_msat + 999) / 1000
4242                         };
4243
4244                 self.closing_fee_limits = Some((proposed_total_fee_satoshis, proposed_max_total_fee_satoshis));
4245                 self.closing_fee_limits.clone().unwrap()
4246         }
4247
4248         /// Returns true if we're ready to commence the closing_signed negotiation phase. This is true
4249         /// after both sides have exchanged a `shutdown` message and all HTLCs have been drained. At
4250         /// this point if we're the funder we should send the initial closing_signed, and in any case
4251         /// shutdown should complete within a reasonable timeframe.
4252         fn closing_negotiation_ready(&self) -> bool {
4253                 self.pending_inbound_htlcs.is_empty() && self.pending_outbound_htlcs.is_empty() &&
4254                         self.channel_state &
4255                                 (BOTH_SIDES_SHUTDOWN_MASK | ChannelState::AwaitingRemoteRevoke as u32 |
4256                                  ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
4257                                 == BOTH_SIDES_SHUTDOWN_MASK &&
4258                         self.pending_update_fee.is_none()
4259         }
4260
4261         /// Checks if the closing_signed negotiation is making appropriate progress, possibly returning
4262         /// an Err if no progress is being made and the channel should be force-closed instead.
4263         /// Should be called on a one-minute timer.
4264         pub fn timer_check_closing_negotiation_progress(&mut self) -> Result<(), ChannelError> {
4265                 if self.closing_negotiation_ready() {
4266                         if self.closing_signed_in_flight {
4267                                 return Err(ChannelError::Close("closing_signed negotiation failed to finish within two timer ticks".to_owned()));
4268                         } else {
4269                                 self.closing_signed_in_flight = true;
4270                         }
4271                 }
4272                 Ok(())
4273         }
4274
4275         pub fn maybe_propose_closing_signed<F: Deref, L: Deref>(
4276                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
4277                 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
4278                 where F::Target: FeeEstimator, L::Target: Logger
4279         {
4280                 if self.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
4281                         return Ok((None, None));
4282                 }
4283
4284                 if !self.is_outbound() {
4285                         if let Some(msg) = &self.pending_counterparty_closing_signed.take() {
4286                                 return self.closing_signed(fee_estimator, &msg);
4287                         }
4288                         return Ok((None, None));
4289                 }
4290
4291                 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
4292
4293                 assert!(self.shutdown_scriptpubkey.is_some());
4294                 let (closing_tx, total_fee_satoshis) = self.build_closing_transaction(our_min_fee, false);
4295                 log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
4296                         our_min_fee, our_max_fee, total_fee_satoshis);
4297
4298                 let sig = self.holder_signer
4299                         .sign_closing_transaction(&closing_tx, &self.secp_ctx)
4300                         .map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
4301
4302                 self.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
4303                 Ok((Some(msgs::ClosingSigned {
4304                         channel_id: self.channel_id,
4305                         fee_satoshis: total_fee_satoshis,
4306                         signature: sig,
4307                         fee_range: Some(msgs::ClosingSignedFeeRange {
4308                                 min_fee_satoshis: our_min_fee,
4309                                 max_fee_satoshis: our_max_fee,
4310                         }),
4311                 }), None))
4312         }
4313
4314         pub fn shutdown<SP: Deref>(
4315                 &mut self, signer_provider: &SP, their_features: &InitFeatures, msg: &msgs::Shutdown
4316         ) -> Result<(Option<msgs::Shutdown>, Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), ChannelError>
4317         where SP::Target: SignerProvider
4318         {
4319                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
4320                         return Err(ChannelError::Close("Peer sent shutdown when we needed a channel_reestablish".to_owned()));
4321                 }
4322                 if self.channel_state < ChannelState::FundingSent as u32 {
4323                         // Spec says we should fail the connection, not the channel, but that's nonsense, there
4324                         // are plenty of reasons you may want to fail a channel pre-funding, and spec says you
4325                         // can do that via error message without getting a connection fail anyway...
4326                         return Err(ChannelError::Close("Peer sent shutdown pre-funding generation".to_owned()));
4327                 }
4328                 for htlc in self.pending_inbound_htlcs.iter() {
4329                         if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
4330                                 return Err(ChannelError::Close("Got shutdown with remote pending HTLCs".to_owned()));
4331                         }
4332                 }
4333                 assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
4334
4335                 if !script::is_bolt2_compliant(&msg.scriptpubkey, their_features) {
4336                         return Err(ChannelError::Warn(format!("Got a nonstandard scriptpubkey ({}) from remote peer", msg.scriptpubkey.to_bytes().to_hex())));
4337                 }
4338
4339                 if self.counterparty_shutdown_scriptpubkey.is_some() {
4340                         if Some(&msg.scriptpubkey) != self.counterparty_shutdown_scriptpubkey.as_ref() {
4341                                 return Err(ChannelError::Warn(format!("Got shutdown request with a scriptpubkey ({}) which did not match their previous scriptpubkey.", msg.scriptpubkey.to_bytes().to_hex())));
4342                         }
4343                 } else {
4344                         self.counterparty_shutdown_scriptpubkey = Some(msg.scriptpubkey.clone());
4345                 }
4346
4347                 // If we have any LocalAnnounced updates we'll probably just get back an update_fail_htlc
4348                 // immediately after the commitment dance, but we can send a Shutdown because we won't send
4349                 // any further commitment updates after we set LocalShutdownSent.
4350                 let send_shutdown = (self.channel_state & ChannelState::LocalShutdownSent as u32) != ChannelState::LocalShutdownSent as u32;
4351
4352                 let update_shutdown_script = match self.shutdown_scriptpubkey {
4353                         Some(_) => false,
4354                         None => {
4355                                 assert!(send_shutdown);
4356                                 let shutdown_scriptpubkey = signer_provider.get_shutdown_scriptpubkey();
4357                                 if !shutdown_scriptpubkey.is_compatible(their_features) {
4358                                         return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
4359                                 }
4360                                 self.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
4361                                 true
4362                         },
4363                 };
4364
4365                 // From here on out, we may not fail!
4366
4367                 self.channel_state |= ChannelState::RemoteShutdownSent as u32;
4368                 self.update_time_counter += 1;
4369
4370                 let monitor_update = if update_shutdown_script {
4371                         self.latest_monitor_update_id += 1;
4372                         let monitor_update = ChannelMonitorUpdate {
4373                                 update_id: self.latest_monitor_update_id,
4374                                 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
4375                                         scriptpubkey: self.get_closing_scriptpubkey(),
4376                                 }],
4377                         };
4378                         self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
4379                         self.pending_monitor_updates.push(monitor_update);
4380                         Some(self.pending_monitor_updates.last().unwrap())
4381                 } else { None };
4382                 let shutdown = if send_shutdown {
4383                         Some(msgs::Shutdown {
4384                                 channel_id: self.channel_id,
4385                                 scriptpubkey: self.get_closing_scriptpubkey(),
4386                         })
4387                 } else { None };
4388
4389                 // We can't send our shutdown until we've committed all of our pending HTLCs, but the
4390                 // remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding
4391                 // cell HTLCs and return them to fail the payment.
4392                 self.holding_cell_update_fee = None;
4393                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
4394                 self.holding_cell_htlc_updates.retain(|htlc_update| {
4395                         match htlc_update {
4396                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
4397                                         dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
4398                                         false
4399                                 },
4400                                 _ => true
4401                         }
4402                 });
4403
4404                 self.channel_state |= ChannelState::LocalShutdownSent as u32;
4405                 self.update_time_counter += 1;
4406
4407                 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
4408         }
4409
4410         fn build_signed_closing_transaction(&self, closing_tx: &ClosingTransaction, counterparty_sig: &Signature, sig: &Signature) -> Transaction {
4411                 let mut tx = closing_tx.trust().built_transaction().clone();
4412
4413                 tx.input[0].witness.push(Vec::new()); // First is the multisig dummy
4414
4415                 let funding_key = self.get_holder_pubkeys().funding_pubkey.serialize();
4416                 let counterparty_funding_key = self.counterparty_funding_pubkey().serialize();
4417                 let mut holder_sig = sig.serialize_der().to_vec();
4418                 holder_sig.push(EcdsaSighashType::All as u8);
4419                 let mut cp_sig = counterparty_sig.serialize_der().to_vec();
4420                 cp_sig.push(EcdsaSighashType::All as u8);
4421                 if funding_key[..] < counterparty_funding_key[..] {
4422                         tx.input[0].witness.push(holder_sig);
4423                         tx.input[0].witness.push(cp_sig);
4424                 } else {
4425                         tx.input[0].witness.push(cp_sig);
4426                         tx.input[0].witness.push(holder_sig);
4427                 }
4428
4429                 tx.input[0].witness.push(self.get_funding_redeemscript().into_bytes());
4430                 tx
4431         }
4432
4433         pub fn closing_signed<F: Deref>(
4434                 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::ClosingSigned)
4435                 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
4436                 where F::Target: FeeEstimator
4437         {
4438                 if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
4439                         return Err(ChannelError::Close("Remote end sent us a closing_signed before both sides provided a shutdown".to_owned()));
4440                 }
4441                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
4442                         return Err(ChannelError::Close("Peer sent closing_signed when we needed a channel_reestablish".to_owned()));
4443                 }
4444                 if !self.pending_inbound_htlcs.is_empty() || !self.pending_outbound_htlcs.is_empty() {
4445                         return Err(ChannelError::Close("Remote end sent us a closing_signed while there were still pending HTLCs".to_owned()));
4446                 }
4447                 if msg.fee_satoshis > TOTAL_BITCOIN_SUPPLY_SATOSHIS { // this is required to stop potential overflow in build_closing_transaction
4448                         return Err(ChannelError::Close("Remote tried to send us a closing tx with > 21 million BTC fee".to_owned()));
4449                 }
4450
4451                 if self.is_outbound() && self.last_sent_closing_fee.is_none() {
4452                         return Err(ChannelError::Close("Remote tried to send a closing_signed when we were supposed to propose the first one".to_owned()));
4453                 }
4454
4455                 if self.channel_state & ChannelState::MonitorUpdateInProgress as u32 != 0 {
4456                         self.pending_counterparty_closing_signed = Some(msg.clone());
4457                         return Ok((None, None));
4458                 }
4459
4460                 let funding_redeemscript = self.get_funding_redeemscript();
4461                 let (mut closing_tx, used_total_fee) = self.build_closing_transaction(msg.fee_satoshis, false);
4462                 if used_total_fee != msg.fee_satoshis {
4463                         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)));
4464                 }
4465                 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.channel_value_satoshis);
4466
4467                 match self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
4468                         Ok(_) => {},
4469                         Err(_e) => {
4470                                 // The remote end may have decided to revoke their output due to inconsistent dust
4471                                 // limits, so check for that case by re-checking the signature here.
4472                                 closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
4473                                 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.channel_value_satoshis);
4474                                 secp_check!(self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, self.counterparty_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
4475                         },
4476                 };
4477
4478                 for outp in closing_tx.trust().built_transaction().output.iter() {
4479                         if !outp.script_pubkey.is_witness_program() && outp.value < MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS {
4480                                 return Err(ChannelError::Close("Remote sent us a closing_signed with a dust output. Always use segwit closing scripts!".to_owned()));
4481                         }
4482                 }
4483
4484                 assert!(self.shutdown_scriptpubkey.is_some());
4485                 if let Some((last_fee, sig)) = self.last_sent_closing_fee {
4486                         if last_fee == msg.fee_satoshis {
4487                                 let tx = self.build_signed_closing_transaction(&mut closing_tx, &msg.signature, &sig);
4488                                 self.channel_state = ChannelState::ShutdownComplete as u32;
4489                                 self.update_time_counter += 1;
4490                                 return Ok((None, Some(tx)));
4491                         }
4492                 }
4493
4494                 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
4495
4496                 macro_rules! propose_fee {
4497                         ($new_fee: expr) => {
4498                                 let (closing_tx, used_fee) = if $new_fee == msg.fee_satoshis {
4499                                         (closing_tx, $new_fee)
4500                                 } else {
4501                                         self.build_closing_transaction($new_fee, false)
4502                                 };
4503
4504                                 let sig = self.holder_signer
4505                                         .sign_closing_transaction(&closing_tx, &self.secp_ctx)
4506                                         .map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
4507
4508                                 let signed_tx = if $new_fee == msg.fee_satoshis {
4509                                         self.channel_state = ChannelState::ShutdownComplete as u32;
4510                                         self.update_time_counter += 1;
4511                                         let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
4512                                         Some(tx)
4513                                 } else { None };
4514
4515                                 self.last_sent_closing_fee = Some((used_fee, sig.clone()));
4516                                 return Ok((Some(msgs::ClosingSigned {
4517                                         channel_id: self.channel_id,
4518                                         fee_satoshis: used_fee,
4519                                         signature: sig,
4520                                         fee_range: Some(msgs::ClosingSignedFeeRange {
4521                                                 min_fee_satoshis: our_min_fee,
4522                                                 max_fee_satoshis: our_max_fee,
4523                                         }),
4524                                 }), signed_tx))
4525                         }
4526                 }
4527
4528                 if let Some(msgs::ClosingSignedFeeRange { min_fee_satoshis, max_fee_satoshis }) = msg.fee_range {
4529                         if msg.fee_satoshis < min_fee_satoshis || msg.fee_satoshis > max_fee_satoshis {
4530                                 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)));
4531                         }
4532                         if max_fee_satoshis < our_min_fee {
4533                                 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)));
4534                         }
4535                         if min_fee_satoshis > our_max_fee {
4536                                 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)));
4537                         }
4538
4539                         if !self.is_outbound() {
4540                                 // They have to pay, so pick the highest fee in the overlapping range.
4541                                 // We should never set an upper bound aside from their full balance
4542                                 debug_assert_eq!(our_max_fee, self.channel_value_satoshis - (self.value_to_self_msat + 999) / 1000);
4543                                 propose_fee!(cmp::min(max_fee_satoshis, our_max_fee));
4544                         } else {
4545                                 if msg.fee_satoshis < our_min_fee || msg.fee_satoshis > our_max_fee {
4546                                         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.",
4547                                                 msg.fee_satoshis, our_min_fee, our_max_fee)));
4548                                 }
4549                                 // The proposed fee is in our acceptable range, accept it and broadcast!
4550                                 propose_fee!(msg.fee_satoshis);
4551                         }
4552                 } else {
4553                         // Old fee style negotiation. We don't bother to enforce whether they are complying
4554                         // with the "making progress" requirements, we just comply and hope for the best.
4555                         if let Some((last_fee, _)) = self.last_sent_closing_fee {
4556                                 if msg.fee_satoshis > last_fee {
4557                                         if msg.fee_satoshis < our_max_fee {
4558                                                 propose_fee!(msg.fee_satoshis);
4559                                         } else if last_fee < our_max_fee {
4560                                                 propose_fee!(our_max_fee);
4561                                         } else {
4562                                                 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)));
4563                                         }
4564                                 } else {
4565                                         if msg.fee_satoshis > our_min_fee {
4566                                                 propose_fee!(msg.fee_satoshis);
4567                                         } else if last_fee > our_min_fee {
4568                                                 propose_fee!(our_min_fee);
4569                                         } else {
4570                                                 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)));
4571                                         }
4572                                 }
4573                         } else {
4574                                 if msg.fee_satoshis < our_min_fee {
4575                                         propose_fee!(our_min_fee);
4576                                 } else if msg.fee_satoshis > our_max_fee {
4577                                         propose_fee!(our_max_fee);
4578                                 } else {
4579                                         propose_fee!(msg.fee_satoshis);
4580                                 }
4581                         }
4582                 }
4583         }
4584
4585         // Public utilities:
4586
4587         pub fn channel_id(&self) -> [u8; 32] {
4588                 self.channel_id
4589         }
4590
4591         // Return the `temporary_channel_id` used during channel establishment.
4592         //
4593         // Will return `None` for channels created prior to LDK version 0.0.115.
4594         pub fn temporary_channel_id(&self) -> Option<[u8; 32]> {
4595                 self.temporary_channel_id
4596         }
4597
4598         pub fn minimum_depth(&self) -> Option<u32> {
4599                 self.minimum_depth
4600         }
4601
4602         /// Gets the "user_id" value passed into the construction of this channel. It has no special
4603         /// meaning and exists only to allow users to have a persistent identifier of a channel.
4604         pub fn get_user_id(&self) -> u128 {
4605                 self.user_id
4606         }
4607
4608         /// Gets the channel's type
4609         pub fn get_channel_type(&self) -> &ChannelTypeFeatures {
4610                 &self.channel_type
4611         }
4612
4613         /// Guaranteed to be Some after both ChannelReady messages have been exchanged (and, thus,
4614         /// is_usable() returns true).
4615         /// Allowed in any state (including after shutdown)
4616         pub fn get_short_channel_id(&self) -> Option<u64> {
4617                 self.short_channel_id
4618         }
4619
4620         /// Allowed in any state (including after shutdown)
4621         pub fn latest_inbound_scid_alias(&self) -> Option<u64> {
4622                 self.latest_inbound_scid_alias
4623         }
4624
4625         /// Allowed in any state (including after shutdown)
4626         pub fn outbound_scid_alias(&self) -> u64 {
4627                 self.outbound_scid_alias
4628         }
4629         /// Only allowed immediately after deserialization if get_outbound_scid_alias returns 0,
4630         /// indicating we were written by LDK prior to 0.0.106 which did not set outbound SCID aliases.
4631         pub fn set_outbound_scid_alias(&mut self, outbound_scid_alias: u64) {
4632                 assert_eq!(self.outbound_scid_alias, 0);
4633                 self.outbound_scid_alias = outbound_scid_alias;
4634         }
4635
4636         /// Returns the funding_txo we either got from our peer, or were given by
4637         /// get_outbound_funding_created.
4638         pub fn get_funding_txo(&self) -> Option<OutPoint> {
4639                 self.channel_transaction_parameters.funding_outpoint
4640         }
4641
4642         /// Returns the block hash in which our funding transaction was confirmed.
4643         pub fn get_funding_tx_confirmed_in(&self) -> Option<BlockHash> {
4644                 self.funding_tx_confirmed_in
4645         }
4646
4647         /// Returns the current number of confirmations on the funding transaction.
4648         pub fn get_funding_tx_confirmations(&self, height: u32) -> u32 {
4649                 if self.funding_tx_confirmation_height == 0 {
4650                         // We either haven't seen any confirmation yet, or observed a reorg.
4651                         return 0;
4652                 }
4653
4654                 height.checked_sub(self.funding_tx_confirmation_height).map_or(0, |c| c + 1)
4655         }
4656
4657         fn get_holder_selected_contest_delay(&self) -> u16 {
4658                 self.channel_transaction_parameters.holder_selected_contest_delay
4659         }
4660
4661         fn get_holder_pubkeys(&self) -> &ChannelPublicKeys {
4662                 &self.channel_transaction_parameters.holder_pubkeys
4663         }
4664
4665         pub fn get_counterparty_selected_contest_delay(&self) -> Option<u16> {
4666                 self.channel_transaction_parameters.counterparty_parameters
4667                         .as_ref().map(|params| params.selected_contest_delay)
4668         }
4669
4670         fn get_counterparty_pubkeys(&self) -> &ChannelPublicKeys {
4671                 &self.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
4672         }
4673
4674         /// Allowed in any state (including after shutdown)
4675         pub fn get_counterparty_node_id(&self) -> PublicKey {
4676                 self.counterparty_node_id
4677         }
4678
4679         /// Allowed in any state (including after shutdown)
4680         pub fn get_holder_htlc_minimum_msat(&self) -> u64 {
4681                 self.holder_htlc_minimum_msat
4682         }
4683
4684         /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
4685         pub fn get_holder_htlc_maximum_msat(&self) -> Option<u64> {
4686                 self.get_htlc_maximum_msat(self.holder_max_htlc_value_in_flight_msat)
4687         }
4688
4689         /// Allowed in any state (including after shutdown)
4690         pub fn get_announced_htlc_max_msat(&self) -> u64 {
4691                 return cmp::min(
4692                         // Upper bound by capacity. We make it a bit less than full capacity to prevent attempts
4693                         // to use full capacity. This is an effort to reduce routing failures, because in many cases
4694                         // channel might have been used to route very small values (either by honest users or as DoS).
4695                         self.channel_value_satoshis * 1000 * 9 / 10,
4696
4697                         self.counterparty_max_htlc_value_in_flight_msat
4698                 );
4699         }
4700
4701         /// Allowed in any state (including after shutdown)
4702         pub fn get_counterparty_htlc_minimum_msat(&self) -> u64 {
4703                 self.counterparty_htlc_minimum_msat
4704         }
4705
4706         /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
4707         pub fn get_counterparty_htlc_maximum_msat(&self) -> Option<u64> {
4708                 self.get_htlc_maximum_msat(self.counterparty_max_htlc_value_in_flight_msat)
4709         }
4710
4711         fn get_htlc_maximum_msat(&self, party_max_htlc_value_in_flight_msat: u64) -> Option<u64> {
4712                 self.counterparty_selected_channel_reserve_satoshis.map(|counterparty_reserve| {
4713                         let holder_reserve = self.holder_selected_channel_reserve_satoshis;
4714                         cmp::min(
4715                                 (self.channel_value_satoshis - counterparty_reserve - holder_reserve) * 1000,
4716                                 party_max_htlc_value_in_flight_msat
4717                         )
4718                 })
4719         }
4720
4721         pub fn get_value_satoshis(&self) -> u64 {
4722                 self.channel_value_satoshis
4723         }
4724
4725         pub fn get_fee_proportional_millionths(&self) -> u32 {
4726                 self.config.options.forwarding_fee_proportional_millionths
4727         }
4728
4729         pub fn get_cltv_expiry_delta(&self) -> u16 {
4730                 cmp::max(self.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
4731         }
4732
4733         pub fn get_max_dust_htlc_exposure_msat(&self) -> u64 {
4734                 self.config.options.max_dust_htlc_exposure_msat
4735         }
4736
4737         /// Returns the previous [`ChannelConfig`] applied to this channel, if any.
4738         pub fn prev_config(&self) -> Option<ChannelConfig> {
4739                 self.prev_config.map(|prev_config| prev_config.0)
4740         }
4741
4742         // Checks whether we should emit a `ChannelPending` event.
4743         pub(crate) fn should_emit_channel_pending_event(&mut self) -> bool {
4744                 self.is_funding_initiated() && !self.channel_pending_event_emitted
4745         }
4746
4747         // Returns whether we already emitted a `ChannelPending` event.
4748         pub(crate) fn channel_pending_event_emitted(&self) -> bool {
4749                 self.channel_pending_event_emitted
4750         }
4751
4752         // Remembers that we already emitted a `ChannelPending` event.
4753         pub(crate) fn set_channel_pending_event_emitted(&mut self) {
4754                 self.channel_pending_event_emitted = true;
4755         }
4756
4757         // Checks whether we should emit a `ChannelReady` event.
4758         pub(crate) fn should_emit_channel_ready_event(&mut self) -> bool {
4759                 self.is_usable() && !self.channel_ready_event_emitted
4760         }
4761
4762         // Remembers that we already emitted a `ChannelReady` event.
4763         pub(crate) fn set_channel_ready_event_emitted(&mut self) {
4764                 self.channel_ready_event_emitted = true;
4765         }
4766
4767         /// Tracks the number of ticks elapsed since the previous [`ChannelConfig`] was updated. Once
4768         /// [`EXPIRE_PREV_CONFIG_TICKS`] is reached, the previous config is considered expired and will
4769         /// no longer be considered when forwarding HTLCs.
4770         pub fn maybe_expire_prev_config(&mut self) {
4771                 if self.prev_config.is_none() {
4772                         return;
4773                 }
4774                 let prev_config = self.prev_config.as_mut().unwrap();
4775                 prev_config.1 += 1;
4776                 if prev_config.1 == EXPIRE_PREV_CONFIG_TICKS {
4777                         self.prev_config = None;
4778                 }
4779         }
4780
4781         /// Returns the current [`ChannelConfig`] applied to the channel.
4782         pub fn config(&self) -> ChannelConfig {
4783                 self.config.options
4784         }
4785
4786         /// Updates the channel's config. A bool is returned indicating whether the config update
4787         /// applied resulted in a new ChannelUpdate message.
4788         pub fn update_config(&mut self, config: &ChannelConfig) -> bool {
4789                 let did_channel_update =
4790                         self.config.options.forwarding_fee_proportional_millionths != config.forwarding_fee_proportional_millionths ||
4791                         self.config.options.forwarding_fee_base_msat != config.forwarding_fee_base_msat ||
4792                         self.config.options.cltv_expiry_delta != config.cltv_expiry_delta;
4793                 if did_channel_update {
4794                         self.prev_config = Some((self.config.options, 0));
4795                         // Update the counter, which backs the ChannelUpdate timestamp, to allow the relay
4796                         // policy change to propagate throughout the network.
4797                         self.update_time_counter += 1;
4798                 }
4799                 self.config.options = *config;
4800                 did_channel_update
4801         }
4802
4803         fn internal_htlc_satisfies_config(
4804                 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32, config: &ChannelConfig,
4805         ) -> Result<(), (&'static str, u16)> {
4806                 let fee = amt_to_forward.checked_mul(config.forwarding_fee_proportional_millionths as u64)
4807                         .and_then(|prop_fee| (prop_fee / 1000000).checked_add(config.forwarding_fee_base_msat as u64));
4808                 if fee.is_none() || htlc.amount_msat < fee.unwrap() ||
4809                         (htlc.amount_msat - fee.unwrap()) < amt_to_forward {
4810                         return Err((
4811                                 "Prior hop has deviated from specified fees parameters or origin node has obsolete ones",
4812                                 0x1000 | 12, // fee_insufficient
4813                         ));
4814                 }
4815                 if (htlc.cltv_expiry as u64) < outgoing_cltv_value as u64 + config.cltv_expiry_delta as u64 {
4816                         return Err((
4817                                 "Forwarding node has tampered with the intended HTLC values or origin node has an obsolete cltv_expiry_delta",
4818                                 0x1000 | 13, // incorrect_cltv_expiry
4819                         ));
4820                 }
4821                 Ok(())
4822         }
4823
4824         /// Determines whether the parameters of an incoming HTLC to be forwarded satisfy the channel's
4825         /// [`ChannelConfig`]. This first looks at the channel's current [`ChannelConfig`], and if
4826         /// unsuccessful, falls back to the previous one if one exists.
4827         pub fn htlc_satisfies_config(
4828                 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32,
4829         ) -> Result<(), (&'static str, u16)> {
4830                 self.internal_htlc_satisfies_config(&htlc, amt_to_forward, outgoing_cltv_value, &self.config())
4831                         .or_else(|err| {
4832                                 if let Some(prev_config) = self.prev_config() {
4833                                         self.internal_htlc_satisfies_config(htlc, amt_to_forward, outgoing_cltv_value, &prev_config)
4834                                 } else {
4835                                         Err(err)
4836                                 }
4837                         })
4838         }
4839
4840         pub fn get_feerate_sat_per_1000_weight(&self) -> u32 {
4841                 self.feerate_per_kw
4842         }
4843
4844         pub fn get_dust_buffer_feerate(&self, outbound_feerate_update: Option<u32>) -> u32 {
4845                 // When calculating our exposure to dust HTLCs, we assume that the channel feerate
4846                 // may, at any point, increase by at least 10 sat/vB (i.e 2530 sat/kWU) or 25%,
4847                 // whichever is higher. This ensures that we aren't suddenly exposed to significantly
4848                 // more dust balance if the feerate increases when we have several HTLCs pending
4849                 // which are near the dust limit.
4850                 let mut feerate_per_kw = self.feerate_per_kw;
4851                 // If there's a pending update fee, use it to ensure we aren't under-estimating
4852                 // potential feerate updates coming soon.
4853                 if let Some((feerate, _)) = self.pending_update_fee {
4854                         feerate_per_kw = cmp::max(feerate_per_kw, feerate);
4855                 }
4856                 if let Some(feerate) = outbound_feerate_update {
4857                         feerate_per_kw = cmp::max(feerate_per_kw, feerate);
4858                 }
4859                 cmp::max(2530, feerate_per_kw * 1250 / 1000)
4860         }
4861
4862         pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
4863                 self.cur_holder_commitment_transaction_number + 1
4864         }
4865
4866         pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
4867                 self.cur_counterparty_commitment_transaction_number + 1 - if self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 }
4868         }
4869
4870         pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
4871                 self.cur_counterparty_commitment_transaction_number + 2
4872         }
4873
4874         #[cfg(test)]
4875         pub fn get_signer(&self) -> &Signer {
4876                 &self.holder_signer
4877         }
4878
4879         #[cfg(test)]
4880         pub fn get_value_stat(&self) -> ChannelValueStat {
4881                 ChannelValueStat {
4882                         value_to_self_msat: self.value_to_self_msat,
4883                         channel_value_msat: self.channel_value_satoshis * 1000,
4884                         channel_reserve_msat: self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000,
4885                         pending_outbound_htlcs_amount_msat: self.pending_outbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
4886                         pending_inbound_htlcs_amount_msat: self.pending_inbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
4887                         holding_cell_outbound_amount_msat: {
4888                                 let mut res = 0;
4889                                 for h in self.holding_cell_htlc_updates.iter() {
4890                                         match h {
4891                                                 &HTLCUpdateAwaitingACK::AddHTLC{amount_msat, .. } => {
4892                                                         res += amount_msat;
4893                                                 }
4894                                                 _ => {}
4895                                         }
4896                                 }
4897                                 res
4898                         },
4899                         counterparty_max_htlc_value_in_flight_msat: self.counterparty_max_htlc_value_in_flight_msat,
4900                         counterparty_dust_limit_msat: self.counterparty_dust_limit_satoshis * 1000,
4901                 }
4902         }
4903
4904         /// Allowed in any state (including after shutdown)
4905         pub fn get_update_time_counter(&self) -> u32 {
4906                 self.update_time_counter
4907         }
4908
4909         pub fn get_latest_monitor_update_id(&self) -> u64 {
4910                 self.latest_monitor_update_id
4911         }
4912
4913         pub fn should_announce(&self) -> bool {
4914                 self.config.announced_channel
4915         }
4916
4917         pub fn is_outbound(&self) -> bool {
4918                 self.channel_transaction_parameters.is_outbound_from_holder
4919         }
4920
4921         /// Gets the fee we'd want to charge for adding an HTLC output to this Channel
4922         /// Allowed in any state (including after shutdown)
4923         pub fn get_outbound_forwarding_fee_base_msat(&self) -> u32 {
4924                 self.config.options.forwarding_fee_base_msat
4925         }
4926
4927         /// Returns true if we've ever received a message from the remote end for this Channel
4928         pub fn have_received_message(&self) -> bool {
4929                 self.channel_state > (ChannelState::OurInitSent as u32)
4930         }
4931
4932         /// Returns true if this channel is fully established and not known to be closing.
4933         /// Allowed in any state (including after shutdown)
4934         pub fn is_usable(&self) -> bool {
4935                 let mask = ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK;
4936                 (self.channel_state & mask) == (ChannelState::ChannelReady as u32) && !self.monitor_pending_channel_ready
4937         }
4938
4939         /// Returns true if this channel is currently available for use. This is a superset of
4940         /// is_usable() and considers things like the channel being temporarily disabled.
4941         /// Allowed in any state (including after shutdown)
4942         pub fn is_live(&self) -> bool {
4943                 self.is_usable() && (self.channel_state & (ChannelState::PeerDisconnected as u32) == 0)
4944         }
4945
4946         /// Returns true if this channel has been marked as awaiting a monitor update to move forward.
4947         /// Allowed in any state (including after shutdown)
4948         pub fn is_awaiting_monitor_update(&self) -> bool {
4949                 (self.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0
4950         }
4951
4952         pub fn get_next_monitor_update(&self) -> Option<&ChannelMonitorUpdate> {
4953                 self.pending_monitor_updates.first()
4954         }
4955
4956         /// Returns true if funding_created was sent/received.
4957         pub fn is_funding_initiated(&self) -> bool {
4958                 self.channel_state >= ChannelState::FundingSent as u32
4959         }
4960
4961         /// Returns true if the channel is awaiting the persistence of the initial ChannelMonitor.
4962         /// If the channel is outbound, this implies we have not yet broadcasted the funding
4963         /// transaction. If the channel is inbound, this implies simply that the channel has not
4964         /// advanced state.
4965         pub fn is_awaiting_initial_mon_persist(&self) -> bool {
4966                 if !self.is_awaiting_monitor_update() { return false; }
4967                 if self.channel_state &
4968                         !(ChannelState::TheirChannelReady as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
4969                                 == ChannelState::FundingSent as u32 {
4970                         // If we're not a 0conf channel, we'll be waiting on a monitor update with only
4971                         // FundingSent set, though our peer could have sent their channel_ready.
4972                         debug_assert!(self.minimum_depth.unwrap_or(1) > 0);
4973                         return true;
4974                 }
4975                 if self.cur_holder_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 &&
4976                         self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
4977                         // If we're a 0-conf channel, we'll move beyond FundingSent immediately even while
4978                         // waiting for the initial monitor persistence. Thus, we check if our commitment
4979                         // transaction numbers have both been iterated only exactly once (for the
4980                         // funding_signed), and we're awaiting monitor update.
4981                         //
4982                         // If we got here, we shouldn't have yet broadcasted the funding transaction (as the
4983                         // only way to get an awaiting-monitor-update state during initial funding is if the
4984                         // initial monitor persistence is still pending).
4985                         //
4986                         // Because deciding we're awaiting initial broadcast spuriously could result in
4987                         // funds-loss (as we don't have a monitor, but have the funding transaction confirmed),
4988                         // we hard-assert here, even in production builds.
4989                         if self.is_outbound() { assert!(self.funding_transaction.is_some()); }
4990                         assert!(self.monitor_pending_channel_ready);
4991                         assert_eq!(self.latest_monitor_update_id, 0);
4992                         return true;
4993                 }
4994                 false
4995         }
4996
4997         /// Returns true if our channel_ready has been sent
4998         pub fn is_our_channel_ready(&self) -> bool {
4999                 (self.channel_state & ChannelState::OurChannelReady as u32) != 0 || self.channel_state >= ChannelState::ChannelReady as u32
5000         }
5001
5002         /// Returns true if our peer has either initiated or agreed to shut down the channel.
5003         pub fn received_shutdown(&self) -> bool {
5004                 (self.channel_state & ChannelState::RemoteShutdownSent as u32) != 0
5005         }
5006
5007         /// Returns true if we either initiated or agreed to shut down the channel.
5008         pub fn sent_shutdown(&self) -> bool {
5009                 (self.channel_state & ChannelState::LocalShutdownSent as u32) != 0
5010         }
5011
5012         /// Returns true if this channel is fully shut down. True here implies that no further actions
5013         /// may/will be taken on this channel, and thus this object should be freed. Any future changes
5014         /// will be handled appropriately by the chain monitor.
5015         pub fn is_shutdown(&self) -> bool {
5016                 if (self.channel_state & ChannelState::ShutdownComplete as u32) == ChannelState::ShutdownComplete as u32  {
5017                         assert!(self.channel_state == ChannelState::ShutdownComplete as u32);
5018                         true
5019                 } else { false }
5020         }
5021
5022         pub fn channel_update_status(&self) -> ChannelUpdateStatus {
5023                 self.channel_update_status
5024         }
5025
5026         pub fn set_channel_update_status(&mut self, status: ChannelUpdateStatus) {
5027                 self.update_time_counter += 1;
5028                 self.channel_update_status = status;
5029         }
5030
5031         fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
5032                 // Called:
5033                 //  * always when a new block/transactions are confirmed with the new height
5034                 //  * when funding is signed with a height of 0
5035                 if self.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) {
5036                         return None;
5037                 }
5038
5039                 let funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
5040                 if funding_tx_confirmations <= 0 {
5041                         self.funding_tx_confirmation_height = 0;
5042                 }
5043
5044                 if funding_tx_confirmations < self.minimum_depth.unwrap_or(0) as i64 {
5045                         return None;
5046                 }
5047
5048                 let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
5049                 let need_commitment_update = if non_shutdown_state == ChannelState::FundingSent as u32 {
5050                         self.channel_state |= ChannelState::OurChannelReady as u32;
5051                         true
5052                 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) {
5053                         self.channel_state = ChannelState::ChannelReady as u32 | (self.channel_state & MULTI_STATE_FLAGS);
5054                         self.update_time_counter += 1;
5055                         true
5056                 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
5057                         // We got a reorg but not enough to trigger a force close, just ignore.
5058                         false
5059                 } else {
5060                         if self.funding_tx_confirmation_height != 0 && self.channel_state < ChannelState::ChannelReady as u32 {
5061                                 // We should never see a funding transaction on-chain until we've received
5062                                 // funding_signed (if we're an outbound channel), or seen funding_generated (if we're
5063                                 // an inbound channel - before that we have no known funding TXID). The fuzzer,
5064                                 // however, may do this and we shouldn't treat it as a bug.
5065                                 #[cfg(not(fuzzing))]
5066                                 panic!("Started confirming a channel in a state pre-FundingSent: {}.\n\
5067                                         Do NOT broadcast a funding transaction manually - let LDK do it for you!",
5068                                         self.channel_state);
5069                         }
5070                         // We got a reorg but not enough to trigger a force close, just ignore.
5071                         false
5072                 };
5073
5074                 if need_commitment_update {
5075                         if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
5076                                 if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
5077                                         let next_per_commitment_point =
5078                                                 self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
5079                                         return Some(msgs::ChannelReady {
5080                                                 channel_id: self.channel_id,
5081                                                 next_per_commitment_point,
5082                                                 short_channel_id_alias: Some(self.outbound_scid_alias),
5083                                         });
5084                                 }
5085                         } else {
5086                                 self.monitor_pending_channel_ready = true;
5087                         }
5088                 }
5089                 None
5090         }
5091
5092         /// When a transaction is confirmed, we check whether it is or spends the funding transaction
5093         /// In the first case, we store the confirmation height and calculating the short channel id.
5094         /// In the second, we simply return an Err indicating we need to be force-closed now.
5095         pub fn transactions_confirmed<NS: Deref, L: Deref>(
5096                 &mut self, block_hash: &BlockHash, height: u32, txdata: &TransactionData,
5097                 genesis_block_hash: BlockHash, node_signer: &NS, user_config: &UserConfig, logger: &L
5098         ) -> Result<(Option<msgs::ChannelReady>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5099         where
5100                 NS::Target: NodeSigner,
5101                 L::Target: Logger
5102         {
5103                 if let Some(funding_txo) = self.get_funding_txo() {
5104                         for &(index_in_block, tx) in txdata.iter() {
5105                                 // Check if the transaction is the expected funding transaction, and if it is,
5106                                 // check that it pays the right amount to the right script.
5107                                 if self.funding_tx_confirmation_height == 0 {
5108                                         if tx.txid() == funding_txo.txid {
5109                                                 let txo_idx = funding_txo.index as usize;
5110                                                 if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.get_funding_redeemscript().to_v0_p2wsh() ||
5111                                                                 tx.output[txo_idx].value != self.channel_value_satoshis {
5112                                                         if self.is_outbound() {
5113                                                                 // If we generated the funding transaction and it doesn't match what it
5114                                                                 // should, the client is really broken and we should just panic and
5115                                                                 // tell them off. That said, because hash collisions happen with high
5116                                                                 // probability in fuzzing mode, if we're fuzzing we just close the
5117                                                                 // channel and move on.
5118                                                                 #[cfg(not(fuzzing))]
5119                                                                 panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
5120                                                         }
5121                                                         self.update_time_counter += 1;
5122                                                         let err_reason = "funding tx had wrong script/value or output index";
5123                                                         return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
5124                                                 } else {
5125                                                         if self.is_outbound() {
5126                                                                 for input in tx.input.iter() {
5127                                                                         if input.witness.is_empty() {
5128                                                                                 // We generated a malleable funding transaction, implying we've
5129                                                                                 // just exposed ourselves to funds loss to our counterparty.
5130                                                                                 #[cfg(not(fuzzing))]
5131                                                                                 panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
5132                                                                         }
5133                                                                 }
5134                                                         }
5135                                                         self.funding_tx_confirmation_height = height;
5136                                                         self.funding_tx_confirmed_in = Some(*block_hash);
5137                                                         self.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
5138                                                                 Ok(scid) => Some(scid),
5139                                                                 Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
5140                                                         }
5141                                                 }
5142                                         }
5143                                         // If we allow 1-conf funding, we may need to check for channel_ready here and
5144                                         // send it immediately instead of waiting for a best_block_updated call (which
5145                                         // may have already happened for this block).
5146                                         if let Some(channel_ready) = self.check_get_channel_ready(height) {
5147                                                 log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
5148                                                 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger);
5149                                                 return Ok((Some(channel_ready), announcement_sigs));
5150                                         }
5151                                 }
5152                                 for inp in tx.input.iter() {
5153                                         if inp.previous_output == funding_txo.into_bitcoin_outpoint() {
5154                                                 log_info!(logger, "Detected channel-closing tx {} spending {}:{}, closing channel {}", tx.txid(), inp.previous_output.txid, inp.previous_output.vout, log_bytes!(self.channel_id()));
5155                                                 return Err(ClosureReason::CommitmentTxConfirmed);
5156                                         }
5157                                 }
5158                         }
5159                 }
5160                 Ok((None, None))
5161         }
5162
5163         /// When a new block is connected, we check the height of the block against outbound holding
5164         /// cell HTLCs in case we need to give up on them prematurely and time them out. Everything
5165         /// else (e.g. commitment transaction broadcasts, HTLC transaction broadcasting, etc) is
5166         /// handled by the ChannelMonitor.
5167         ///
5168         /// If we return Err, the channel may have been closed, at which point the standard
5169         /// requirements apply - no calls may be made except those explicitly stated to be allowed
5170         /// post-shutdown.
5171         ///
5172         /// May return some HTLCs (and their payment_hash) which have timed out and should be failed
5173         /// back.
5174         pub fn best_block_updated<NS: Deref, L: Deref>(
5175                 &mut self, height: u32, highest_header_time: u32, genesis_block_hash: BlockHash,
5176                 node_signer: &NS, user_config: &UserConfig, logger: &L
5177         ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5178         where
5179                 NS::Target: NodeSigner,
5180                 L::Target: Logger
5181         {
5182                 self.do_best_block_updated(height, highest_header_time, Some((genesis_block_hash, node_signer, user_config)), logger)
5183         }
5184
5185         fn do_best_block_updated<NS: Deref, L: Deref>(
5186                 &mut self, height: u32, highest_header_time: u32,
5187                 genesis_node_signer: Option<(BlockHash, &NS, &UserConfig)>, logger: &L
5188         ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
5189         where
5190                 NS::Target: NodeSigner,
5191                 L::Target: Logger
5192         {
5193                 let mut timed_out_htlcs = Vec::new();
5194                 // This mirrors the check in ChannelManager::decode_update_add_htlc_onion, refusing to
5195                 // forward an HTLC when our counterparty should almost certainly just fail it for expiring
5196                 // ~now.
5197                 let unforwarded_htlc_cltv_limit = height + LATENCY_GRACE_PERIOD_BLOCKS;
5198                 self.holding_cell_htlc_updates.retain(|htlc_update| {
5199                         match htlc_update {
5200                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, ref cltv_expiry, .. } => {
5201                                         if *cltv_expiry <= unforwarded_htlc_cltv_limit {
5202                                                 timed_out_htlcs.push((source.clone(), payment_hash.clone()));
5203                                                 false
5204                                         } else { true }
5205                                 },
5206                                 _ => true
5207                         }
5208                 });
5209
5210                 self.update_time_counter = cmp::max(self.update_time_counter, highest_header_time);
5211
5212                 if let Some(channel_ready) = self.check_get_channel_ready(height) {
5213                         let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
5214                                 self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
5215                         } else { None };
5216                         log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
5217                         return Ok((Some(channel_ready), timed_out_htlcs, announcement_sigs));
5218                 }
5219
5220                 let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
5221                 if non_shutdown_state >= ChannelState::ChannelReady as u32 ||
5222                    (non_shutdown_state & ChannelState::OurChannelReady as u32) == ChannelState::OurChannelReady as u32 {
5223                         let mut funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
5224                         if self.funding_tx_confirmation_height == 0 {
5225                                 // Note that check_get_channel_ready may reset funding_tx_confirmation_height to
5226                                 // zero if it has been reorged out, however in either case, our state flags
5227                                 // indicate we've already sent a channel_ready
5228                                 funding_tx_confirmations = 0;
5229                         }
5230
5231                         // If we've sent channel_ready (or have both sent and received channel_ready), and
5232                         // the funding transaction has become unconfirmed,
5233                         // close the channel and hope we can get the latest state on chain (because presumably
5234                         // the funding transaction is at least still in the mempool of most nodes).
5235                         //
5236                         // Note that ideally we wouldn't force-close if we see *any* reorg on a 1-conf or
5237                         // 0-conf channel, but not doing so may lead to the
5238                         // `ChannelManager::short_to_chan_info` map  being inconsistent, so we currently have
5239                         // to.
5240                         if funding_tx_confirmations == 0 && self.funding_tx_confirmed_in.is_some() {
5241                                 let err_reason = format!("Funding transaction was un-confirmed. Locked at {} confs, now have {} confs.",
5242                                         self.minimum_depth.unwrap(), funding_tx_confirmations);
5243                                 return Err(ClosureReason::ProcessingError { err: err_reason });
5244                         }
5245                 } else if !self.is_outbound() && self.funding_tx_confirmed_in.is_none() &&
5246                                 height >= self.channel_creation_height + FUNDING_CONF_DEADLINE_BLOCKS {
5247                         log_info!(logger, "Closing channel {} due to funding timeout", log_bytes!(self.channel_id));
5248                         // If funding_tx_confirmed_in is unset, the channel must not be active
5249                         assert!(non_shutdown_state <= ChannelState::ChannelReady as u32);
5250                         assert_eq!(non_shutdown_state & ChannelState::OurChannelReady as u32, 0);
5251                         return Err(ClosureReason::FundingTimedOut);
5252                 }
5253
5254                 let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
5255                         self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
5256                 } else { None };
5257                 Ok((None, timed_out_htlcs, announcement_sigs))
5258         }
5259
5260         /// Indicates the funding transaction is no longer confirmed in the main chain. This may
5261         /// force-close the channel, but may also indicate a harmless reorganization of a block or two
5262         /// before the channel has reached channel_ready and we can just wait for more blocks.
5263         pub fn funding_transaction_unconfirmed<L: Deref>(&mut self, logger: &L) -> Result<(), ClosureReason> where L::Target: Logger {
5264                 if self.funding_tx_confirmation_height != 0 {
5265                         // We handle the funding disconnection by calling best_block_updated with a height one
5266                         // below where our funding was connected, implying a reorg back to conf_height - 1.
5267                         let reorg_height = self.funding_tx_confirmation_height - 1;
5268                         // We use the time field to bump the current time we set on channel updates if its
5269                         // larger. If we don't know that time has moved forward, we can just set it to the last
5270                         // time we saw and it will be ignored.
5271                         let best_time = self.update_time_counter;
5272                         match self.do_best_block_updated(reorg_height, best_time, None::<(BlockHash, &&NodeSigner, &UserConfig)>, logger) {
5273                                 Ok((channel_ready, timed_out_htlcs, announcement_sigs)) => {
5274                                         assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
5275                                         assert!(timed_out_htlcs.is_empty(), "We can't have accepted HTLCs with a timeout before our funding confirmation?");
5276                                         assert!(announcement_sigs.is_none(), "We can't generate an announcement_sigs with 0 confirmations?");
5277                                         Ok(())
5278                                 },
5279                                 Err(e) => Err(e)
5280                         }
5281                 } else {
5282                         // We never learned about the funding confirmation anyway, just ignore
5283                         Ok(())
5284                 }
5285         }
5286
5287         // Methods to get unprompted messages to send to the remote end (or where we already returned
5288         // something in the handler for the message that prompted this message):
5289
5290         pub fn get_open_channel(&self, chain_hash: BlockHash) -> msgs::OpenChannel {
5291                 if !self.is_outbound() {
5292                         panic!("Tried to open a channel for an inbound channel?");
5293                 }
5294                 if self.channel_state != ChannelState::OurInitSent as u32 {
5295                         panic!("Cannot generate an open_channel after we've moved forward");
5296                 }
5297
5298                 if self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
5299                         panic!("Tried to send an open_channel for a channel that has already advanced");
5300                 }
5301
5302                 let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
5303                 let keys = self.get_holder_pubkeys();
5304
5305                 msgs::OpenChannel {
5306                         chain_hash,
5307                         temporary_channel_id: self.channel_id,
5308                         funding_satoshis: self.channel_value_satoshis,
5309                         push_msat: self.channel_value_satoshis * 1000 - self.value_to_self_msat,
5310                         dust_limit_satoshis: self.holder_dust_limit_satoshis,
5311                         max_htlc_value_in_flight_msat: self.holder_max_htlc_value_in_flight_msat,
5312                         channel_reserve_satoshis: self.holder_selected_channel_reserve_satoshis,
5313                         htlc_minimum_msat: self.holder_htlc_minimum_msat,
5314                         feerate_per_kw: self.feerate_per_kw as u32,
5315                         to_self_delay: self.get_holder_selected_contest_delay(),
5316                         max_accepted_htlcs: OUR_MAX_HTLCS,
5317                         funding_pubkey: keys.funding_pubkey,
5318                         revocation_basepoint: keys.revocation_basepoint,
5319                         payment_point: keys.payment_point,
5320                         delayed_payment_basepoint: keys.delayed_payment_basepoint,
5321                         htlc_basepoint: keys.htlc_basepoint,
5322                         first_per_commitment_point,
5323                         channel_flags: if self.config.announced_channel {1} else {0},
5324                         shutdown_scriptpubkey: OptionalField::Present(match &self.shutdown_scriptpubkey {
5325                                 Some(script) => script.clone().into_inner(),
5326                                 None => Builder::new().into_script(),
5327                         }),
5328                         channel_type: Some(self.channel_type.clone()),
5329                 }
5330         }
5331
5332         pub fn inbound_is_awaiting_accept(&self) -> bool {
5333                 self.inbound_awaiting_accept
5334         }
5335
5336         /// Sets this channel to accepting 0conf, must be done before `get_accept_channel`
5337         pub fn set_0conf(&mut self) {
5338                 assert!(self.inbound_awaiting_accept);
5339                 self.minimum_depth = Some(0);
5340         }
5341
5342         /// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannel`] message which
5343         /// should be sent back to the counterparty node.
5344         ///
5345         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
5346         pub fn accept_inbound_channel(&mut self, user_id: u128) -> msgs::AcceptChannel {
5347                 if self.is_outbound() {
5348                         panic!("Tried to send accept_channel for an outbound channel?");
5349                 }
5350                 if self.channel_state != (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32) {
5351                         panic!("Tried to send accept_channel after channel had moved forward");
5352                 }
5353                 if self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
5354                         panic!("Tried to send an accept_channel for a channel that has already advanced");
5355                 }
5356                 if !self.inbound_awaiting_accept {
5357                         panic!("The inbound channel has already been accepted");
5358                 }
5359
5360                 self.user_id = user_id;
5361                 self.inbound_awaiting_accept = false;
5362
5363                 self.generate_accept_channel_message()
5364         }
5365
5366         /// This function is used to explicitly generate a [`msgs::AcceptChannel`] message for an
5367         /// inbound channel. If the intention is to accept an inbound channel, use
5368         /// [`Channel::accept_inbound_channel`] instead.
5369         ///
5370         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
5371         fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
5372                 let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
5373                 let keys = self.get_holder_pubkeys();
5374
5375                 msgs::AcceptChannel {
5376                         temporary_channel_id: self.channel_id,
5377                         dust_limit_satoshis: self.holder_dust_limit_satoshis,
5378                         max_htlc_value_in_flight_msat: self.holder_max_htlc_value_in_flight_msat,
5379                         channel_reserve_satoshis: self.holder_selected_channel_reserve_satoshis,
5380                         htlc_minimum_msat: self.holder_htlc_minimum_msat,
5381                         minimum_depth: self.minimum_depth.unwrap(),
5382                         to_self_delay: self.get_holder_selected_contest_delay(),
5383                         max_accepted_htlcs: OUR_MAX_HTLCS,
5384                         funding_pubkey: keys.funding_pubkey,
5385                         revocation_basepoint: keys.revocation_basepoint,
5386                         payment_point: keys.payment_point,
5387                         delayed_payment_basepoint: keys.delayed_payment_basepoint,
5388                         htlc_basepoint: keys.htlc_basepoint,
5389                         first_per_commitment_point,
5390                         shutdown_scriptpubkey: OptionalField::Present(match &self.shutdown_scriptpubkey {
5391                                 Some(script) => script.clone().into_inner(),
5392                                 None => Builder::new().into_script(),
5393                         }),
5394                         channel_type: Some(self.channel_type.clone()),
5395                         #[cfg(taproot)]
5396                         next_local_nonce: None,
5397                 }
5398         }
5399
5400         /// Enables the possibility for tests to extract a [`msgs::AcceptChannel`] message for an
5401         /// inbound channel without accepting it.
5402         ///
5403         /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
5404         #[cfg(test)]
5405         pub fn get_accept_channel_message(&self) -> msgs::AcceptChannel {
5406                 self.generate_accept_channel_message()
5407         }
5408
5409         /// If an Err is returned, it is a ChannelError::Close (for get_outbound_funding_created)
5410         fn get_outbound_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
5411                 let counterparty_keys = self.build_remote_transaction_keys();
5412                 let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
5413                 Ok(self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
5414                                 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
5415         }
5416
5417         /// Updates channel state with knowledge of the funding transaction's txid/index, and generates
5418         /// a funding_created message for the remote peer.
5419         /// Panics if called at some time other than immediately after initial handshake, if called twice,
5420         /// or if called on an inbound channel.
5421         /// Note that channel_id changes during this call!
5422         /// Do NOT broadcast the funding transaction until after a successful funding_signed call!
5423         /// If an Err is returned, it is a ChannelError::Close.
5424         pub fn get_outbound_funding_created<L: Deref>(&mut self, funding_transaction: Transaction, funding_txo: OutPoint, logger: &L) -> Result<msgs::FundingCreated, ChannelError> where L::Target: Logger {
5425                 if !self.is_outbound() {
5426                         panic!("Tried to create outbound funding_created message on an inbound channel!");
5427                 }
5428                 if self.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
5429                         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)");
5430                 }
5431                 if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
5432                                 self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
5433                                 self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
5434                         panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
5435                 }
5436
5437                 self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
5438                 self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
5439
5440                 let signature = match self.get_outbound_funding_created_signature(logger) {
5441                         Ok(res) => res,
5442                         Err(e) => {
5443                                 log_error!(logger, "Got bad signatures: {:?}!", e);
5444                                 self.channel_transaction_parameters.funding_outpoint = None;
5445                                 return Err(e);
5446                         }
5447                 };
5448
5449                 let temporary_channel_id = self.channel_id;
5450
5451                 // Now that we're past error-generating stuff, update our local state:
5452
5453                 self.channel_state = ChannelState::FundingCreated as u32;
5454                 self.channel_id = funding_txo.to_channel_id();
5455                 self.funding_transaction = Some(funding_transaction);
5456
5457                 Ok(msgs::FundingCreated {
5458                         temporary_channel_id,
5459                         funding_txid: funding_txo.txid,
5460                         funding_output_index: funding_txo.index,
5461                         signature,
5462                         #[cfg(taproot)]
5463                         partial_signature_with_nonce: None,
5464                         #[cfg(taproot)]
5465                         next_local_nonce: None,
5466                 })
5467         }
5468
5469         /// Gets an UnsignedChannelAnnouncement for this channel. The channel must be publicly
5470         /// announceable and available for use (have exchanged ChannelReady messages in both
5471         /// directions). Should be used for both broadcasted announcements and in response to an
5472         /// AnnouncementSignatures message from the remote peer.
5473         ///
5474         /// Will only fail if we're not in a state where channel_announcement may be sent (including
5475         /// closing).
5476         ///
5477         /// This will only return ChannelError::Ignore upon failure.
5478         fn get_channel_announcement<NS: Deref>(
5479                 &self, node_signer: &NS, chain_hash: BlockHash, user_config: &UserConfig,
5480         ) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
5481                 if !self.config.announced_channel {
5482                         return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
5483                 }
5484                 if !self.is_usable() {
5485                         return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
5486                 }
5487
5488                 let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
5489                         .map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
5490                 let counterparty_node_id = NodeId::from_pubkey(&self.get_counterparty_node_id());
5491                 let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();
5492
5493                 let msg = msgs::UnsignedChannelAnnouncement {
5494                         features: channelmanager::provided_channel_features(&user_config),
5495                         chain_hash,
5496                         short_channel_id: self.get_short_channel_id().unwrap(),
5497                         node_id_1: if were_node_one { node_id } else { counterparty_node_id },
5498                         node_id_2: if were_node_one { counterparty_node_id } else { node_id },
5499                         bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &self.get_holder_pubkeys().funding_pubkey } else { self.counterparty_funding_pubkey() }),
5500                         bitcoin_key_2: NodeId::from_pubkey(if were_node_one { self.counterparty_funding_pubkey() } else { &self.get_holder_pubkeys().funding_pubkey }),
5501                         excess_data: Vec::new(),
5502                 };
5503
5504                 Ok(msg)
5505         }
5506
5507         fn get_announcement_sigs<NS: Deref, L: Deref>(
5508                 &mut self, node_signer: &NS, genesis_block_hash: BlockHash, user_config: &UserConfig,
5509                 best_block_height: u32, logger: &L
5510         ) -> Option<msgs::AnnouncementSignatures>
5511         where
5512                 NS::Target: NodeSigner,
5513                 L::Target: Logger
5514         {
5515                 if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
5516                         return None;
5517                 }
5518
5519                 if !self.is_usable() {
5520                         return None;
5521                 }
5522
5523                 if self.channel_state & ChannelState::PeerDisconnected as u32 != 0 {
5524                         log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
5525                         return None;
5526                 }
5527
5528                 if self.announcement_sigs_state != AnnouncementSigsState::NotSent {
5529                         return None;
5530                 }
5531
5532                 log_trace!(logger, "Creating an announcement_signatures message for channel {}", log_bytes!(self.channel_id()));
5533                 let announcement = match self.get_channel_announcement(node_signer, genesis_block_hash, user_config) {
5534                         Ok(a) => a,
5535                         Err(e) => {
5536                                 log_trace!(logger, "{:?}", e);
5537                                 return None;
5538                         }
5539                 };
5540                 let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
5541                         Err(_) => {
5542                                 log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
5543                                 return None;
5544                         },
5545                         Ok(v) => v
5546                 };
5547                 let our_bitcoin_sig = match self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
5548                         Err(_) => {
5549                                 log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
5550                                 return None;
5551                         },
5552                         Ok(v) => v
5553                 };
5554                 self.announcement_sigs_state = AnnouncementSigsState::MessageSent;
5555
5556                 Some(msgs::AnnouncementSignatures {
5557                         channel_id: self.channel_id(),
5558                         short_channel_id: self.get_short_channel_id().unwrap(),
5559                         node_signature: our_node_sig,
5560                         bitcoin_signature: our_bitcoin_sig,
5561                 })
5562         }
5563
5564         /// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are
5565         /// available.
5566         fn sign_channel_announcement<NS: Deref>(
5567                 &self, node_signer: &NS, announcement: msgs::UnsignedChannelAnnouncement
5568         ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
5569                 if let Some((their_node_sig, their_bitcoin_sig)) = self.announcement_sigs {
5570                         let our_node_key = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
5571                                 .map_err(|_| ChannelError::Ignore("Signer failed to retrieve own public key".to_owned()))?);
5572                         let were_node_one = announcement.node_id_1 == our_node_key;
5573
5574                         let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
5575                                 .map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
5576                         let our_bitcoin_sig = self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
5577                                 .map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
5578                         Ok(msgs::ChannelAnnouncement {
5579                                 node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
5580                                 node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
5581                                 bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
5582                                 bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
5583                                 contents: announcement,
5584                         })
5585                 } else {
5586                         Err(ChannelError::Ignore("Attempted to sign channel announcement before we'd received announcement_signatures".to_string()))
5587                 }
5588         }
5589
5590         /// Processes an incoming announcement_signatures message, providing a fully-signed
5591         /// channel_announcement message which we can broadcast and storing our counterparty's
5592         /// signatures for later reconstruction/rebroadcast of the channel_announcement.
5593         pub fn announcement_signatures<NS: Deref>(
5594                 &mut self, node_signer: &NS, chain_hash: BlockHash, best_block_height: u32,
5595                 msg: &msgs::AnnouncementSignatures, user_config: &UserConfig
5596         ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
5597                 let announcement = self.get_channel_announcement(node_signer, chain_hash, user_config)?;
5598
5599                 let msghash = hash_to_message!(&Sha256d::hash(&announcement.encode()[..])[..]);
5600
5601                 if self.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.get_counterparty_node_id()).is_err() {
5602                         return Err(ChannelError::Close(format!(
5603                                 "Bad announcement_signatures. Failed to verify node_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_node_key is {:?}",
5604                                  &announcement, self.get_counterparty_node_id())));
5605                 }
5606                 if self.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.counterparty_funding_pubkey()).is_err() {
5607                         return Err(ChannelError::Close(format!(
5608                                 "Bad announcement_signatures. Failed to verify bitcoin_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_bitcoin_key is ({:?})",
5609                                 &announcement, self.counterparty_funding_pubkey())));
5610                 }
5611
5612                 self.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
5613                 if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
5614                         return Err(ChannelError::Ignore(
5615                                 "Got announcement_signatures prior to the required six confirmations - we may not have received a block yet that our peer has".to_owned()));
5616                 }
5617
5618                 self.sign_channel_announcement(node_signer, announcement)
5619         }
5620
5621         /// Gets a signed channel_announcement for this channel, if we previously received an
5622         /// announcement_signatures from our counterparty.
5623         pub fn get_signed_channel_announcement<NS: Deref>(
5624                 &self, node_signer: &NS, chain_hash: BlockHash, best_block_height: u32, user_config: &UserConfig
5625         ) -> Option<msgs::ChannelAnnouncement> where NS::Target: NodeSigner {
5626                 if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
5627                         return None;
5628                 }
5629                 let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
5630                         Ok(res) => res,
5631                         Err(_) => return None,
5632                 };
5633                 match self.sign_channel_announcement(node_signer, announcement) {
5634                         Ok(res) => Some(res),
5635                         Err(_) => None,
5636                 }
5637         }
5638
5639         /// May panic if called on a channel that wasn't immediately-previously
5640         /// self.remove_uncommitted_htlcs_and_mark_paused()'d
5641         pub fn get_channel_reestablish<L: Deref>(&self, logger: &L) -> msgs::ChannelReestablish where L::Target: Logger {
5642                 assert_eq!(self.channel_state & ChannelState::PeerDisconnected as u32, ChannelState::PeerDisconnected as u32);
5643                 assert_ne!(self.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
5644                 // Prior to static_remotekey, my_current_per_commitment_point was critical to claiming
5645                 // current to_remote balances. However, it no longer has any use, and thus is now simply
5646                 // set to a dummy (but valid, as required by the spec) public key.
5647                 // fuzzing mode marks a subset of pubkeys as invalid so that we can hit "invalid pubkey"
5648                 // branches, but we unwrap it below, so we arbitrarily select a dummy pubkey which is both
5649                 // valid, and valid in fuzzing mode's arbitrary validity criteria:
5650                 let mut pk = [2; 33]; pk[1] = 0xff;
5651                 let dummy_pubkey = PublicKey::from_slice(&pk).unwrap();
5652                 let data_loss_protect = if self.cur_counterparty_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
5653                         let remote_last_secret = self.commitment_secrets.get_secret(self.cur_counterparty_commitment_transaction_number + 2).unwrap();
5654                         log_trace!(logger, "Enough info to generate a Data Loss Protect with per_commitment_secret {} for channel {}", log_bytes!(remote_last_secret), log_bytes!(self.channel_id()));
5655                         OptionalField::Present(DataLossProtect {
5656                                 your_last_per_commitment_secret: remote_last_secret,
5657                                 my_current_per_commitment_point: dummy_pubkey
5658                         })
5659                 } else {
5660                         log_info!(logger, "Sending a data_loss_protect with no previous remote per_commitment_secret for channel {}", log_bytes!(self.channel_id()));
5661                         OptionalField::Present(DataLossProtect {
5662                                 your_last_per_commitment_secret: [0;32],
5663                                 my_current_per_commitment_point: dummy_pubkey,
5664                         })
5665                 };
5666                 msgs::ChannelReestablish {
5667                         channel_id: self.channel_id(),
5668                         // The protocol has two different commitment number concepts - the "commitment
5669                         // transaction number", which starts from 0 and counts up, and the "revocation key
5670                         // index" which starts at INITIAL_COMMITMENT_NUMBER and counts down. We track
5671                         // commitment transaction numbers by the index which will be used to reveal the
5672                         // revocation key for that commitment transaction, which means we have to convert them
5673                         // to protocol-level commitment numbers here...
5674
5675                         // next_local_commitment_number is the next commitment_signed number we expect to
5676                         // receive (indicating if they need to resend one that we missed).
5677                         next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number,
5678                         // We have to set next_remote_commitment_number to the next revoke_and_ack we expect to
5679                         // receive, however we track it by the next commitment number for a remote transaction
5680                         // (which is one further, as they always revoke previous commitment transaction, not
5681                         // the one we send) so we have to decrement by 1. Note that if
5682                         // cur_counterparty_commitment_transaction_number is INITIAL_COMMITMENT_NUMBER we will have
5683                         // dropped this channel on disconnect as it hasn't yet reached FundingSent so we can't
5684                         // overflow here.
5685                         next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.cur_counterparty_commitment_transaction_number - 1,
5686                         data_loss_protect,
5687                 }
5688         }
5689
5690
5691         // Send stuff to our remote peers:
5692
5693         /// Queues up an outbound HTLC to send by placing it in the holding cell. You should call
5694         /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
5695         /// commitment update.
5696         ///
5697         /// `Err`s will only be [`ChannelError::Ignore`].
5698         pub fn queue_add_htlc<L: Deref>(&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
5699                 onion_routing_packet: msgs::OnionPacket, logger: &L)
5700         -> Result<(), ChannelError> where L::Target: Logger {
5701                 self
5702                         .send_htlc(amount_msat, payment_hash, cltv_expiry, source, onion_routing_packet, true, logger)
5703                         .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
5704                         .map_err(|err| {
5705                                 if let ChannelError::Ignore(_) = err { /* fine */ }
5706                                 else { debug_assert!(false, "Queueing cannot trigger channel failure"); }
5707                                 err
5708                         })
5709         }
5710
5711         /// Adds a pending outbound HTLC to this channel, note that you probably want
5712         /// [`Self::send_htlc_and_commit`] instead cause you'll want both messages at once.
5713         ///
5714         /// This returns an optional UpdateAddHTLC as we may be in a state where we cannot add HTLCs on
5715         /// the wire:
5716         /// * In cases where we're waiting on the remote peer to send us a revoke_and_ack, we
5717         ///   wouldn't be able to determine what they actually ACK'ed if we have two sets of updates
5718         ///   awaiting ACK.
5719         /// * In cases where we're marked MonitorUpdateInProgress, we cannot commit to a new state as
5720         ///   we may not yet have sent the previous commitment update messages and will need to
5721         ///   regenerate them.
5722         ///
5723         /// You MUST call [`Self::send_commitment_no_state_update`] prior to calling any other methods
5724         /// on this [`Channel`] if `force_holding_cell` is false.
5725         ///
5726         /// `Err`s will only be [`ChannelError::Ignore`].
5727         fn send_htlc<L: Deref>(&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
5728                 onion_routing_packet: msgs::OnionPacket, mut force_holding_cell: bool, logger: &L)
5729         -> Result<Option<msgs::UpdateAddHTLC>, ChannelError> where L::Target: Logger {
5730                 if (self.channel_state & (ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelReady as u32) {
5731                         return Err(ChannelError::Ignore("Cannot send HTLC until channel is fully established and we haven't started shutting down".to_owned()));
5732                 }
5733                 let channel_total_msat = self.channel_value_satoshis * 1000;
5734                 if amount_msat > channel_total_msat {
5735                         return Err(ChannelError::Ignore(format!("Cannot send amount {}, because it is more than the total value of the channel {}", amount_msat, channel_total_msat)));
5736                 }
5737
5738                 if amount_msat == 0 {
5739                         return Err(ChannelError::Ignore("Cannot send 0-msat HTLC".to_owned()));
5740                 }
5741
5742                 if amount_msat < self.counterparty_htlc_minimum_msat {
5743                         return Err(ChannelError::Ignore(format!("Cannot send less than their minimum HTLC value ({})", self.counterparty_htlc_minimum_msat)));
5744                 }
5745
5746                 if (self.channel_state & (ChannelState::PeerDisconnected as u32)) != 0 {
5747                         // Note that this should never really happen, if we're !is_live() on receipt of an
5748                         // incoming HTLC for relay will result in us rejecting the HTLC and we won't allow
5749                         // the user to send directly into a !is_live() channel. However, if we
5750                         // disconnected during the time the previous hop was doing the commitment dance we may
5751                         // end up getting here after the forwarding delay. In any case, returning an
5752                         // IgnoreError will get ChannelManager to do the right thing and fail backwards now.
5753                         return Err(ChannelError::Ignore("Cannot send an HTLC while disconnected from channel counterparty".to_owned()));
5754                 }
5755
5756                 let inbound_stats = self.get_inbound_pending_htlc_stats(None);
5757                 let outbound_stats = self.get_outbound_pending_htlc_stats(None);
5758                 if outbound_stats.pending_htlcs + 1 > self.counterparty_max_accepted_htlcs as u32 {
5759                         return Err(ChannelError::Ignore(format!("Cannot push more than their max accepted HTLCs ({})", self.counterparty_max_accepted_htlcs)));
5760                 }
5761                 // Check their_max_htlc_value_in_flight_msat
5762                 if outbound_stats.pending_htlcs_value_msat + amount_msat > self.counterparty_max_htlc_value_in_flight_msat {
5763                         return Err(ChannelError::Ignore(format!("Cannot send value that would put us over the max HTLC value in flight our peer will accept ({})", self.counterparty_max_htlc_value_in_flight_msat)));
5764                 }
5765
5766                 let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
5767                 let commitment_stats = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, true, logger);
5768                 if !self.is_outbound() {
5769                         // Check that we won't violate the remote channel reserve by adding this HTLC.
5770                         let htlc_candidate = HTLCCandidate::new(amount_msat, HTLCInitiator::LocalOffered);
5771                         let counterparty_commit_tx_fee_msat = self.next_remote_commit_tx_fee_msat(htlc_candidate, None);
5772                         let holder_selected_chan_reserve_msat = self.holder_selected_channel_reserve_satoshis * 1000;
5773                         if commitment_stats.remote_balance_msat < counterparty_commit_tx_fee_msat + holder_selected_chan_reserve_msat {
5774                                 return Err(ChannelError::Ignore("Cannot send value that would put counterparty balance under holder-announced channel reserve value".to_owned()));
5775                         }
5776                 }
5777
5778                 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
5779                         (0, 0)
5780                 } else {
5781                         let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
5782                         (dust_buffer_feerate * htlc_success_tx_weight(false) / 1000,
5783                                 dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000)
5784                 };
5785                 let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.counterparty_dust_limit_satoshis;
5786                 if amount_msat / 1000 < exposure_dust_limit_success_sats {
5787                         let on_counterparty_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat + amount_msat;
5788                         if on_counterparty_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
5789                                 return Err(ChannelError::Ignore(format!("Cannot send value that would put our exposure to dust HTLCs at {} over the limit {} on counterparty commitment tx",
5790                                         on_counterparty_dust_htlc_exposure_msat, self.get_max_dust_htlc_exposure_msat())));
5791                         }
5792                 }
5793
5794                 let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
5795                 if amount_msat / 1000 <  exposure_dust_limit_timeout_sats {
5796                         let on_holder_dust_htlc_exposure_msat = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat + amount_msat;
5797                         if on_holder_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
5798                                 return Err(ChannelError::Ignore(format!("Cannot send value that would put our exposure to dust HTLCs at {} over the limit {} on holder commitment tx",
5799                                         on_holder_dust_htlc_exposure_msat, self.get_max_dust_htlc_exposure_msat())));
5800                         }
5801                 }
5802
5803                 let holder_balance_msat = commitment_stats.local_balance_msat - outbound_stats.holding_cell_msat;
5804                 if holder_balance_msat < amount_msat {
5805                         return Err(ChannelError::Ignore(format!("Cannot send value that would overdraw remaining funds. Amount: {}, pending value to self {}", amount_msat, holder_balance_msat)));
5806                 }
5807
5808                 // `2 *` and extra HTLC are for the fee spike buffer.
5809                 let commit_tx_fee_msat = if self.is_outbound() {
5810                         let htlc_candidate = HTLCCandidate::new(amount_msat, HTLCInitiator::LocalOffered);
5811                         FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE * self.next_local_commit_tx_fee_msat(htlc_candidate, Some(()))
5812                 } else { 0 };
5813                 if holder_balance_msat - amount_msat < commit_tx_fee_msat {
5814                         return Err(ChannelError::Ignore(format!("Cannot send value that would not leave enough to pay for fees. Pending value to self: {}. local_commit_tx_fee {}", holder_balance_msat, commit_tx_fee_msat)));
5815                 }
5816
5817                 // Check self.counterparty_selected_channel_reserve_satoshis (the amount we must keep as
5818                 // reserve for the remote to have something to claim if we misbehave)
5819                 let chan_reserve_msat = self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000;
5820                 if holder_balance_msat - amount_msat - commit_tx_fee_msat < chan_reserve_msat {
5821                         return Err(ChannelError::Ignore(format!("Cannot send value that would put our balance under counterparty-announced channel reserve value ({})", chan_reserve_msat)));
5822                 }
5823
5824                 if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
5825                         force_holding_cell = true;
5826                 }
5827
5828                 // Now update local state:
5829                 if force_holding_cell {
5830                         self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
5831                                 amount_msat,
5832                                 payment_hash,
5833                                 cltv_expiry,
5834                                 source,
5835                                 onion_routing_packet,
5836                         });
5837                         return Ok(None);
5838                 }
5839
5840                 self.pending_outbound_htlcs.push(OutboundHTLCOutput {
5841                         htlc_id: self.next_holder_htlc_id,
5842                         amount_msat,
5843                         payment_hash: payment_hash.clone(),
5844                         cltv_expiry,
5845                         state: OutboundHTLCState::LocalAnnounced(Box::new(onion_routing_packet.clone())),
5846                         source,
5847                 });
5848
5849                 let res = msgs::UpdateAddHTLC {
5850                         channel_id: self.channel_id,
5851                         htlc_id: self.next_holder_htlc_id,
5852                         amount_msat,
5853                         payment_hash,
5854                         cltv_expiry,
5855                         onion_routing_packet,
5856                 };
5857                 self.next_holder_htlc_id += 1;
5858
5859                 Ok(Some(res))
5860         }
5861
5862         fn build_commitment_no_status_check<L: Deref>(&mut self, logger: &L) -> ChannelMonitorUpdate where L::Target: Logger {
5863                 log_trace!(logger, "Updating HTLC state for a newly-sent commitment_signed...");
5864                 // We can upgrade the status of some HTLCs that are waiting on a commitment, even if we
5865                 // fail to generate this, we still are at least at a position where upgrading their status
5866                 // is acceptable.
5867                 for htlc in self.pending_inbound_htlcs.iter_mut() {
5868                         let new_state = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref forward_info) = &htlc.state {
5869                                 Some(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info.clone()))
5870                         } else { None };
5871                         if let Some(state) = new_state {
5872                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
5873                                 htlc.state = state;
5874                         }
5875                 }
5876                 for htlc in self.pending_outbound_htlcs.iter_mut() {
5877                         if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
5878                                 log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
5879                                 // Grab the preimage, if it exists, instead of cloning
5880                                 let mut reason = OutboundHTLCOutcome::Success(None);
5881                                 mem::swap(outcome, &mut reason);
5882                                 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
5883                         }
5884                 }
5885                 if let Some((feerate, update_state)) = self.pending_update_fee {
5886                         if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {
5887                                 debug_assert!(!self.is_outbound());
5888                                 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
5889                                 self.feerate_per_kw = feerate;
5890                                 self.pending_update_fee = None;
5891                         }
5892                 }
5893                 self.resend_order = RAACommitmentOrder::RevokeAndACKFirst;
5894
5895                 let (counterparty_commitment_txid, mut htlcs_ref) = self.build_commitment_no_state_update(logger);
5896                 let htlcs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)> =
5897                         htlcs_ref.drain(..).map(|(htlc, htlc_source)| (htlc, htlc_source.map(|source_ref| Box::new(source_ref.clone())))).collect();
5898
5899                 if self.announcement_sigs_state == AnnouncementSigsState::MessageSent {
5900                         self.announcement_sigs_state = AnnouncementSigsState::Committed;
5901                 }
5902
5903                 self.latest_monitor_update_id += 1;
5904                 let monitor_update = ChannelMonitorUpdate {
5905                         update_id: self.latest_monitor_update_id,
5906                         updates: vec![ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
5907                                 commitment_txid: counterparty_commitment_txid,
5908                                 htlc_outputs: htlcs.clone(),
5909                                 commitment_number: self.cur_counterparty_commitment_transaction_number,
5910                                 their_per_commitment_point: self.counterparty_cur_commitment_point.unwrap()
5911                         }]
5912                 };
5913                 self.channel_state |= ChannelState::AwaitingRemoteRevoke as u32;
5914                 monitor_update
5915         }
5916
5917         fn build_commitment_no_state_update<L: Deref>(&self, logger: &L) -> (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>) where L::Target: Logger {
5918                 let counterparty_keys = self.build_remote_transaction_keys();
5919                 let commitment_stats = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
5920                 let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
5921
5922                 #[cfg(any(test, fuzzing))]
5923                 {
5924                         if !self.is_outbound() {
5925                                 let projected_commit_tx_info = self.next_remote_commitment_tx_fee_info_cached.lock().unwrap().take();
5926                                 *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
5927                                 if let Some(info) = projected_commit_tx_info {
5928                                         let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
5929                                         if info.total_pending_htlcs == total_pending_htlcs
5930                                                 && info.next_holder_htlc_id == self.next_holder_htlc_id
5931                                                 && info.next_counterparty_htlc_id == self.next_counterparty_htlc_id
5932                                                 && info.feerate == self.feerate_per_kw {
5933                                                         let actual_fee = Self::commit_tx_fee_msat(self.feerate_per_kw, commitment_stats.num_nondust_htlcs, self.opt_anchors());
5934                                                         assert_eq!(actual_fee, info.fee);
5935                                                 }
5936                                 }
5937                         }
5938                 }
5939
5940                 (counterparty_commitment_txid, commitment_stats.htlcs_included)
5941         }
5942
5943         /// Only fails in case of signer rejection. Used for channel_reestablish commitment_signed
5944         /// generation when we shouldn't change HTLC/channel state.
5945         fn send_commitment_no_state_update<L: Deref>(&self, logger: &L) -> Result<(msgs::CommitmentSigned, (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>)), ChannelError> where L::Target: Logger {
5946                 // Get the fee tests from `build_commitment_no_state_update`
5947                 #[cfg(any(test, fuzzing))]
5948                 self.build_commitment_no_state_update(logger);
5949
5950                 let counterparty_keys = self.build_remote_transaction_keys();
5951                 let commitment_stats = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
5952                 let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
5953                 let (signature, htlc_signatures);
5954
5955                 {
5956                         let mut htlcs = Vec::with_capacity(commitment_stats.htlcs_included.len());
5957                         for &(ref htlc, _) in commitment_stats.htlcs_included.iter() {
5958                                 htlcs.push(htlc);
5959                         }
5960
5961                         let res = self.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
5962                                 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
5963                         signature = res.0;
5964                         htlc_signatures = res.1;
5965
5966                         log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {} in channel {}",
5967                                 encode::serialize_hex(&commitment_stats.tx.trust().built_transaction().transaction),
5968                                 &counterparty_commitment_txid, encode::serialize_hex(&self.get_funding_redeemscript()),
5969                                 log_bytes!(signature.serialize_compact()[..]), log_bytes!(self.channel_id()));
5970
5971                         for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(htlcs) {
5972                                 log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {} in channel {}",
5973                                         encode::serialize_hex(&chan_utils::build_htlc_transaction(&counterparty_commitment_txid, commitment_stats.feerate_per_kw, self.get_holder_selected_contest_delay(), htlc, self.opt_anchors(), false, &counterparty_keys.broadcaster_delayed_payment_key, &counterparty_keys.revocation_key)),
5974                                         encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, self.opt_anchors(), &counterparty_keys)),
5975                                         log_bytes!(counterparty_keys.broadcaster_htlc_key.serialize()),
5976                                         log_bytes!(htlc_sig.serialize_compact()[..]), log_bytes!(self.channel_id()));
5977                         }
5978                 }
5979
5980                 Ok((msgs::CommitmentSigned {
5981                         channel_id: self.channel_id,
5982                         signature,
5983                         htlc_signatures,
5984                         #[cfg(taproot)]
5985                         partial_signature_with_nonce: None,
5986                 }, (counterparty_commitment_txid, commitment_stats.htlcs_included)))
5987         }
5988
5989         /// Adds a pending outbound HTLC to this channel, and builds a new remote commitment
5990         /// transaction and generates the corresponding [`ChannelMonitorUpdate`] in one go.
5991         ///
5992         /// Shorthand for calling [`Self::send_htlc`] followed by a commitment update, see docs on
5993         /// [`Self::send_htlc`] and [`Self::build_commitment_no_state_update`] for more info.
5994         pub fn send_htlc_and_commit<L: Deref>(&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource, onion_routing_packet: msgs::OnionPacket, logger: &L) -> Result<Option<&ChannelMonitorUpdate>, ChannelError> where L::Target: Logger {
5995                 let send_res = self.send_htlc(amount_msat, payment_hash, cltv_expiry, source, onion_routing_packet, false, logger);
5996                 if let Err(e) = &send_res { if let ChannelError::Ignore(_) = e {} else { debug_assert!(false, "Sending cannot trigger channel failure"); } }
5997                 match send_res? {
5998                         Some(_) => {
5999                                 let monitor_update = self.build_commitment_no_status_check(logger);
6000                                 self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
6001                                 self.pending_monitor_updates.push(monitor_update);
6002                                 Ok(Some(self.pending_monitor_updates.last().unwrap()))
6003                         },
6004                         None => Ok(None)
6005                 }
6006         }
6007
6008         /// Get forwarding information for the counterparty.
6009         pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
6010                 self.counterparty_forwarding_info.clone()
6011         }
6012
6013         pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<(), ChannelError> {
6014                 if msg.contents.htlc_minimum_msat >= self.channel_value_satoshis * 1000 {
6015                         return Err(ChannelError::Close("Minimum htlc value is greater than channel value".to_string()));
6016                 }
6017                 self.counterparty_forwarding_info = Some(CounterpartyForwardingInfo {
6018                         fee_base_msat: msg.contents.fee_base_msat,
6019                         fee_proportional_millionths: msg.contents.fee_proportional_millionths,
6020                         cltv_expiry_delta: msg.contents.cltv_expiry_delta
6021                 });
6022
6023                 Ok(())
6024         }
6025
6026         /// Begins the shutdown process, getting a message for the remote peer and returning all
6027         /// holding cell HTLCs for payment failure.
6028         ///
6029         /// May jump to the channel being fully shutdown (see [`Self::is_shutdown`]) in which case no
6030         /// [`ChannelMonitorUpdate`] will be returned).
6031         pub fn get_shutdown<SP: Deref>(&mut self, signer_provider: &SP, their_features: &InitFeatures,
6032                 target_feerate_sats_per_kw: Option<u32>)
6033         -> Result<(msgs::Shutdown, Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), APIError>
6034         where SP::Target: SignerProvider {
6035                 for htlc in self.pending_outbound_htlcs.iter() {
6036                         if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
6037                                 return Err(APIError::APIMisuseError{err: "Cannot begin shutdown with pending HTLCs. Process pending events first".to_owned()});
6038                         }
6039                 }
6040                 if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK != 0 {
6041                         if (self.channel_state & ChannelState::LocalShutdownSent as u32) == ChannelState::LocalShutdownSent as u32 {
6042                                 return Err(APIError::APIMisuseError{err: "Shutdown already in progress".to_owned()});
6043                         }
6044                         else if (self.channel_state & ChannelState::RemoteShutdownSent as u32) == ChannelState::RemoteShutdownSent as u32 {
6045                                 return Err(APIError::ChannelUnavailable{err: "Shutdown already in progress by remote".to_owned()});
6046                         }
6047                 }
6048                 assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
6049                 if self.channel_state & (ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0 {
6050                         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()});
6051                 }
6052
6053                 // If we haven't funded the channel yet, we don't need to bother ensuring the shutdown
6054                 // script is set, we just force-close and call it a day.
6055                 let mut chan_closed = false;
6056                 if self.channel_state < ChannelState::FundingSent as u32 {
6057                         chan_closed = true;
6058                 }
6059
6060                 let update_shutdown_script = match self.shutdown_scriptpubkey {
6061                         Some(_) => false,
6062                         None if !chan_closed => {
6063                                 let shutdown_scriptpubkey = signer_provider.get_shutdown_scriptpubkey();
6064                                 if !shutdown_scriptpubkey.is_compatible(their_features) {
6065                                         return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
6066                                 }
6067                                 self.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
6068                                 true
6069                         },
6070                         None => false,
6071                 };
6072
6073                 // From here on out, we may not fail!
6074                 self.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
6075                 if self.channel_state < ChannelState::FundingSent as u32 {
6076                         self.channel_state = ChannelState::ShutdownComplete as u32;
6077                 } else {
6078                         self.channel_state |= ChannelState::LocalShutdownSent as u32;
6079                 }
6080                 self.update_time_counter += 1;
6081
6082                 let monitor_update = if update_shutdown_script {
6083                         self.latest_monitor_update_id += 1;
6084                         let monitor_update = ChannelMonitorUpdate {
6085                                 update_id: self.latest_monitor_update_id,
6086                                 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
6087                                         scriptpubkey: self.get_closing_scriptpubkey(),
6088                                 }],
6089                         };
6090                         self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
6091                         self.pending_monitor_updates.push(monitor_update);
6092                         Some(self.pending_monitor_updates.last().unwrap())
6093                 } else { None };
6094                 let shutdown = msgs::Shutdown {
6095                         channel_id: self.channel_id,
6096                         scriptpubkey: self.get_closing_scriptpubkey(),
6097                 };
6098
6099                 // Go ahead and drop holding cell updates as we'd rather fail payments than wait to send
6100                 // our shutdown until we've committed all of the pending changes.
6101                 self.holding_cell_update_fee = None;
6102                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
6103                 self.holding_cell_htlc_updates.retain(|htlc_update| {
6104                         match htlc_update {
6105                                 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
6106                                         dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
6107                                         false
6108                                 },
6109                                 _ => true
6110                         }
6111                 });
6112
6113                 debug_assert!(!self.is_shutdown() || monitor_update.is_none(),
6114                         "we can't both complete shutdown and return a monitor update");
6115
6116                 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
6117         }
6118
6119         /// Gets the latest commitment transaction and any dependent transactions for relay (forcing
6120         /// shutdown of this channel - no more calls into this Channel may be made afterwards except
6121         /// those explicitly stated to be allowed after shutdown completes, eg some simple getters).
6122         /// Also returns the list of payment_hashes for channels which we can safely fail backwards
6123         /// immediately (others we will have to allow to time out).
6124         pub fn force_shutdown(&mut self, should_broadcast: bool) -> (Option<(OutPoint, ChannelMonitorUpdate)>, Vec<(HTLCSource, PaymentHash, PublicKey, [u8; 32])>) {
6125                 // Note that we MUST only generate a monitor update that indicates force-closure - we're
6126                 // called during initialization prior to the chain_monitor in the encompassing ChannelManager
6127                 // being fully configured in some cases. Thus, its likely any monitor events we generate will
6128                 // be delayed in being processed! See the docs for `ChannelManagerReadArgs` for more.
6129                 assert!(self.channel_state != ChannelState::ShutdownComplete as u32);
6130
6131                 // We go ahead and "free" any holding cell HTLCs or HTLCs we haven't yet committed to and
6132                 // return them to fail the payment.
6133                 let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
6134                 let counterparty_node_id = self.get_counterparty_node_id();
6135                 for htlc_update in self.holding_cell_htlc_updates.drain(..) {
6136                         match htlc_update {
6137                                 HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. } => {
6138                                         dropped_outbound_htlcs.push((source, payment_hash, counterparty_node_id, self.channel_id));
6139                                 },
6140                                 _ => {}
6141                         }
6142                 }
6143                 let monitor_update = if let Some(funding_txo) = self.get_funding_txo() {
6144                         // If we haven't yet exchanged funding signatures (ie channel_state < FundingSent),
6145                         // returning a channel monitor update here would imply a channel monitor update before
6146                         // we even registered the channel monitor to begin with, which is invalid.
6147                         // Thus, if we aren't actually at a point where we could conceivably broadcast the
6148                         // funding transaction, don't return a funding txo (which prevents providing the
6149                         // monitor update to the user, even if we return one).
6150                         // See test_duplicate_chan_id and test_pre_lockin_no_chan_closed_update for more.
6151                         if self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::ChannelReady as u32 | ChannelState::ShutdownComplete as u32) != 0 {
6152                                 self.latest_monitor_update_id = CLOSED_CHANNEL_UPDATE_ID;
6153                                 Some((funding_txo, ChannelMonitorUpdate {
6154                                         update_id: self.latest_monitor_update_id,
6155                                         updates: vec![ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast }],
6156                                 }))
6157                         } else { None }
6158                 } else { None };
6159
6160                 self.channel_state = ChannelState::ShutdownComplete as u32;
6161                 self.update_time_counter += 1;
6162                 (monitor_update, dropped_outbound_htlcs)
6163         }
6164
6165         pub fn inflight_htlc_sources(&self) -> impl Iterator<Item=(&HTLCSource, &PaymentHash)> {
6166                 self.holding_cell_htlc_updates.iter()
6167                         .flat_map(|htlc_update| {
6168                                 match htlc_update {
6169                                         HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. }
6170                                                 => Some((source, payment_hash)),
6171                                         _ => None,
6172                                 }
6173                         })
6174                         .chain(self.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
6175         }
6176 }
6177
6178 const SERIALIZATION_VERSION: u8 = 3;
6179 const MIN_SERIALIZATION_VERSION: u8 = 2;
6180
6181 impl_writeable_tlv_based_enum!(InboundHTLCRemovalReason,;
6182         (0, FailRelay),
6183         (1, FailMalformed),
6184         (2, Fulfill),
6185 );
6186
6187 impl Writeable for ChannelUpdateStatus {
6188         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6189                 // We only care about writing out the current state as it was announced, ie only either
6190                 // Enabled or Disabled. In the case of DisabledStaged, we most recently announced the
6191                 // channel as enabled, so we write 0. For EnabledStaged, we similarly write a 1.
6192                 match self {
6193                         ChannelUpdateStatus::Enabled => 0u8.write(writer)?,
6194                         ChannelUpdateStatus::DisabledStaged => 0u8.write(writer)?,
6195                         ChannelUpdateStatus::EnabledStaged => 1u8.write(writer)?,
6196                         ChannelUpdateStatus::Disabled => 1u8.write(writer)?,
6197                 }
6198                 Ok(())
6199         }
6200 }
6201
6202 impl Readable for ChannelUpdateStatus {
6203         fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
6204                 Ok(match <u8 as Readable>::read(reader)? {
6205                         0 => ChannelUpdateStatus::Enabled,
6206                         1 => ChannelUpdateStatus::Disabled,
6207                         _ => return Err(DecodeError::InvalidValue),
6208                 })
6209         }
6210 }
6211
6212 impl Writeable for AnnouncementSigsState {
6213         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6214                 // We only care about writing out the current state as if we had just disconnected, at
6215                 // which point we always set anything but AnnouncementSigsReceived to NotSent.
6216                 match self {
6217                         AnnouncementSigsState::NotSent => 0u8.write(writer),
6218                         AnnouncementSigsState::MessageSent => 0u8.write(writer),
6219                         AnnouncementSigsState::Committed => 0u8.write(writer),
6220                         AnnouncementSigsState::PeerReceived => 1u8.write(writer),
6221                 }
6222         }
6223 }
6224
6225 impl Readable for AnnouncementSigsState {
6226         fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
6227                 Ok(match <u8 as Readable>::read(reader)? {
6228                         0 => AnnouncementSigsState::NotSent,
6229                         1 => AnnouncementSigsState::PeerReceived,
6230                         _ => return Err(DecodeError::InvalidValue),
6231                 })
6232         }
6233 }
6234
6235 impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
6236         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6237                 // Note that we write out as if remove_uncommitted_htlcs_and_mark_paused had just been
6238                 // called.
6239
6240                 write_ver_prefix!(writer, MIN_SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
6241
6242                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6243                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We write
6244                 // the low bytes now and the optional high bytes later.
6245                 let user_id_low = self.user_id as u64;
6246                 user_id_low.write(writer)?;
6247
6248                 // Version 1 deserializers expected to read parts of the config object here. Version 2
6249                 // deserializers (0.0.99) now read config through TLVs, and as we now require them for
6250                 // `minimum_depth` we simply write dummy values here.
6251                 writer.write_all(&[0; 8])?;
6252
6253                 self.channel_id.write(writer)?;
6254                 (self.channel_state | ChannelState::PeerDisconnected as u32).write(writer)?;
6255                 self.channel_value_satoshis.write(writer)?;
6256
6257                 self.latest_monitor_update_id.write(writer)?;
6258
6259                 let mut key_data = VecWriter(Vec::new());
6260                 self.holder_signer.write(&mut key_data)?;
6261                 assert!(key_data.0.len() < core::usize::MAX);
6262                 assert!(key_data.0.len() < core::u32::MAX as usize);
6263                 (key_data.0.len() as u32).write(writer)?;
6264                 writer.write_all(&key_data.0[..])?;
6265
6266                 // Write out the old serialization for shutdown_pubkey for backwards compatibility, if
6267                 // deserialized from that format.
6268                 match self.shutdown_scriptpubkey.as_ref().and_then(|script| script.as_legacy_pubkey()) {
6269                         Some(shutdown_pubkey) => shutdown_pubkey.write(writer)?,
6270                         None => [0u8; PUBLIC_KEY_SIZE].write(writer)?,
6271                 }
6272                 self.destination_script.write(writer)?;
6273
6274                 self.cur_holder_commitment_transaction_number.write(writer)?;
6275                 self.cur_counterparty_commitment_transaction_number.write(writer)?;
6276                 self.value_to_self_msat.write(writer)?;
6277
6278                 let mut dropped_inbound_htlcs = 0;
6279                 for htlc in self.pending_inbound_htlcs.iter() {
6280                         if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
6281                                 dropped_inbound_htlcs += 1;
6282                         }
6283                 }
6284                 (self.pending_inbound_htlcs.len() as u64 - dropped_inbound_htlcs).write(writer)?;
6285                 for htlc in self.pending_inbound_htlcs.iter() {
6286                         if let &InboundHTLCState::RemoteAnnounced(_) = &htlc.state {
6287                                 continue; // Drop
6288                         }
6289                         htlc.htlc_id.write(writer)?;
6290                         htlc.amount_msat.write(writer)?;
6291                         htlc.cltv_expiry.write(writer)?;
6292                         htlc.payment_hash.write(writer)?;
6293                         match &htlc.state {
6294                                 &InboundHTLCState::RemoteAnnounced(_) => unreachable!(),
6295                                 &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref htlc_state) => {
6296                                         1u8.write(writer)?;
6297                                         htlc_state.write(writer)?;
6298                                 },
6299                                 &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(ref htlc_state) => {
6300                                         2u8.write(writer)?;
6301                                         htlc_state.write(writer)?;
6302                                 },
6303                                 &InboundHTLCState::Committed => {
6304                                         3u8.write(writer)?;
6305                                 },
6306                                 &InboundHTLCState::LocalRemoved(ref removal_reason) => {
6307                                         4u8.write(writer)?;
6308                                         removal_reason.write(writer)?;
6309                                 },
6310                         }
6311                 }
6312
6313                 let mut preimages: Vec<&Option<PaymentPreimage>> = vec![];
6314
6315                 (self.pending_outbound_htlcs.len() as u64).write(writer)?;
6316                 for htlc in self.pending_outbound_htlcs.iter() {
6317                         htlc.htlc_id.write(writer)?;
6318                         htlc.amount_msat.write(writer)?;
6319                         htlc.cltv_expiry.write(writer)?;
6320                         htlc.payment_hash.write(writer)?;
6321                         htlc.source.write(writer)?;
6322                         match &htlc.state {
6323                                 &OutboundHTLCState::LocalAnnounced(ref onion_packet) => {
6324                                         0u8.write(writer)?;
6325                                         onion_packet.write(writer)?;
6326                                 },
6327                                 &OutboundHTLCState::Committed => {
6328                                         1u8.write(writer)?;
6329                                 },
6330                                 &OutboundHTLCState::RemoteRemoved(_) => {
6331                                         // Treat this as a Committed because we haven't received the CS - they'll
6332                                         // resend the claim/fail on reconnect as we all (hopefully) the missing CS.
6333                                         1u8.write(writer)?;
6334                                 },
6335                                 &OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref outcome) => {
6336                                         3u8.write(writer)?;
6337                                         if let OutboundHTLCOutcome::Success(preimage) = outcome {
6338                                                 preimages.push(preimage);
6339                                         }
6340                                         let reason: Option<&HTLCFailReason> = outcome.into();
6341                                         reason.write(writer)?;
6342                                 }
6343                                 &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) => {
6344                                         4u8.write(writer)?;
6345                                         if let OutboundHTLCOutcome::Success(preimage) = outcome {
6346                                                 preimages.push(preimage);
6347                                         }
6348                                         let reason: Option<&HTLCFailReason> = outcome.into();
6349                                         reason.write(writer)?;
6350                                 }
6351                         }
6352                 }
6353
6354                 (self.holding_cell_htlc_updates.len() as u64).write(writer)?;
6355                 for update in self.holding_cell_htlc_updates.iter() {
6356                         match update {
6357                                 &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, ref cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet } => {
6358                                         0u8.write(writer)?;
6359                                         amount_msat.write(writer)?;
6360                                         cltv_expiry.write(writer)?;
6361                                         payment_hash.write(writer)?;
6362                                         source.write(writer)?;
6363                                         onion_routing_packet.write(writer)?;
6364                                 },
6365                                 &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, ref htlc_id } => {
6366                                         1u8.write(writer)?;
6367                                         payment_preimage.write(writer)?;
6368                                         htlc_id.write(writer)?;
6369                                 },
6370                                 &HTLCUpdateAwaitingACK::FailHTLC { ref htlc_id, ref err_packet } => {
6371                                         2u8.write(writer)?;
6372                                         htlc_id.write(writer)?;
6373                                         err_packet.write(writer)?;
6374                                 }
6375                         }
6376                 }
6377
6378                 match self.resend_order {
6379                         RAACommitmentOrder::CommitmentFirst => 0u8.write(writer)?,
6380                         RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
6381                 }
6382
6383                 self.monitor_pending_channel_ready.write(writer)?;
6384                 self.monitor_pending_revoke_and_ack.write(writer)?;
6385                 self.monitor_pending_commitment_signed.write(writer)?;
6386
6387                 (self.monitor_pending_forwards.len() as u64).write(writer)?;
6388                 for &(ref pending_forward, ref htlc_id) in self.monitor_pending_forwards.iter() {
6389                         pending_forward.write(writer)?;
6390                         htlc_id.write(writer)?;
6391                 }
6392
6393                 (self.monitor_pending_failures.len() as u64).write(writer)?;
6394                 for &(ref htlc_source, ref payment_hash, ref fail_reason) in self.monitor_pending_failures.iter() {
6395                         htlc_source.write(writer)?;
6396                         payment_hash.write(writer)?;
6397                         fail_reason.write(writer)?;
6398                 }
6399
6400                 if self.is_outbound() {
6401                         self.pending_update_fee.map(|(a, _)| a).write(writer)?;
6402                 } else if let Some((feerate, FeeUpdateState::AwaitingRemoteRevokeToAnnounce)) = self.pending_update_fee {
6403                         Some(feerate).write(writer)?;
6404                 } else {
6405                         // As for inbound HTLCs, if the update was only announced and never committed in a
6406                         // commitment_signed, drop it.
6407                         None::<u32>.write(writer)?;
6408                 }
6409                 self.holding_cell_update_fee.write(writer)?;
6410
6411                 self.next_holder_htlc_id.write(writer)?;
6412                 (self.next_counterparty_htlc_id - dropped_inbound_htlcs).write(writer)?;
6413                 self.update_time_counter.write(writer)?;
6414                 self.feerate_per_kw.write(writer)?;
6415
6416                 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
6417                 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
6418                 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
6419                 // consider the stale state on reload.
6420                 0u8.write(writer)?;
6421
6422                 self.funding_tx_confirmed_in.write(writer)?;
6423                 self.funding_tx_confirmation_height.write(writer)?;
6424                 self.short_channel_id.write(writer)?;
6425
6426                 self.counterparty_dust_limit_satoshis.write(writer)?;
6427                 self.holder_dust_limit_satoshis.write(writer)?;
6428                 self.counterparty_max_htlc_value_in_flight_msat.write(writer)?;
6429
6430                 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
6431                 self.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;
6432
6433                 self.counterparty_htlc_minimum_msat.write(writer)?;
6434                 self.holder_htlc_minimum_msat.write(writer)?;
6435                 self.counterparty_max_accepted_htlcs.write(writer)?;
6436
6437                 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
6438                 self.minimum_depth.unwrap_or(0).write(writer)?;
6439
6440                 match &self.counterparty_forwarding_info {
6441                         Some(info) => {
6442                                 1u8.write(writer)?;
6443                                 info.fee_base_msat.write(writer)?;
6444                                 info.fee_proportional_millionths.write(writer)?;
6445                                 info.cltv_expiry_delta.write(writer)?;
6446                         },
6447                         None => 0u8.write(writer)?
6448                 }
6449
6450                 self.channel_transaction_parameters.write(writer)?;
6451                 self.funding_transaction.write(writer)?;
6452
6453                 self.counterparty_cur_commitment_point.write(writer)?;
6454                 self.counterparty_prev_commitment_point.write(writer)?;
6455                 self.counterparty_node_id.write(writer)?;
6456
6457                 self.counterparty_shutdown_scriptpubkey.write(writer)?;
6458
6459                 self.commitment_secrets.write(writer)?;
6460
6461                 self.channel_update_status.write(writer)?;
6462
6463                 #[cfg(any(test, fuzzing))]
6464                 (self.historical_inbound_htlc_fulfills.len() as u64).write(writer)?;
6465                 #[cfg(any(test, fuzzing))]
6466                 for htlc in self.historical_inbound_htlc_fulfills.iter() {
6467                         htlc.write(writer)?;
6468                 }
6469
6470                 // If the channel type is something other than only-static-remote-key, then we need to have
6471                 // older clients fail to deserialize this channel at all. If the type is
6472                 // only-static-remote-key, we simply consider it "default" and don't write the channel type
6473                 // out at all.
6474                 let chan_type = if self.channel_type != ChannelTypeFeatures::only_static_remote_key() {
6475                         Some(&self.channel_type) } else { None };
6476
6477                 // The same logic applies for `holder_selected_channel_reserve_satoshis` values other than
6478                 // the default, and when `holder_max_htlc_value_in_flight_msat` is configured to be set to
6479                 // a different percentage of the channel value then 10%, which older versions of LDK used
6480                 // to set it to before the percentage was made configurable.
6481                 let serialized_holder_selected_reserve =
6482                         if self.holder_selected_channel_reserve_satoshis != Self::get_legacy_default_holder_selected_channel_reserve_satoshis(self.channel_value_satoshis)
6483                         { Some(self.holder_selected_channel_reserve_satoshis) } else { None };
6484
6485                 let mut old_max_in_flight_percent_config = UserConfig::default().channel_handshake_config;
6486                 old_max_in_flight_percent_config.max_inbound_htlc_value_in_flight_percent_of_channel = MAX_IN_FLIGHT_PERCENT_LEGACY;
6487                 let serialized_holder_htlc_max_in_flight =
6488                         if self.holder_max_htlc_value_in_flight_msat != Self::get_holder_max_htlc_value_in_flight_msat(self.channel_value_satoshis, &old_max_in_flight_percent_config)
6489                         { Some(self.holder_max_htlc_value_in_flight_msat) } else { None };
6490
6491                 let channel_pending_event_emitted = Some(self.channel_pending_event_emitted);
6492                 let channel_ready_event_emitted = Some(self.channel_ready_event_emitted);
6493
6494                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6495                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. Therefore,
6496                 // we write the high bytes as an option here.
6497                 let user_id_high_opt = Some((self.user_id >> 64) as u64);
6498
6499                 write_tlv_fields!(writer, {
6500                         (0, self.announcement_sigs, option),
6501                         // minimum_depth and counterparty_selected_channel_reserve_satoshis used to have a
6502                         // default value instead of being Option<>al. Thus, to maintain compatibility we write
6503                         // them twice, once with their original default values above, and once as an option
6504                         // here. On the read side, old versions will simply ignore the odd-type entries here,
6505                         // and new versions map the default values to None and allow the TLV entries here to
6506                         // override that.
6507                         (1, self.minimum_depth, option),
6508                         (2, chan_type, option),
6509                         (3, self.counterparty_selected_channel_reserve_satoshis, option),
6510                         (4, serialized_holder_selected_reserve, option),
6511                         (5, self.config, required),
6512                         (6, serialized_holder_htlc_max_in_flight, option),
6513                         (7, self.shutdown_scriptpubkey, option),
6514                         (9, self.target_closing_feerate_sats_per_kw, option),
6515                         (11, self.monitor_pending_finalized_fulfills, vec_type),
6516                         (13, self.channel_creation_height, required),
6517                         (15, preimages, vec_type),
6518                         (17, self.announcement_sigs_state, required),
6519                         (19, self.latest_inbound_scid_alias, option),
6520                         (21, self.outbound_scid_alias, required),
6521                         (23, channel_ready_event_emitted, option),
6522                         (25, user_id_high_opt, option),
6523                         (27, self.channel_keys_id, required),
6524                         (29, self.temporary_channel_id, option),
6525                         (31, channel_pending_event_emitted, option),
6526                 });
6527
6528                 Ok(())
6529         }
6530 }
6531
6532 const MAX_ALLOC_SIZE: usize = 64*1024;
6533 impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)> for Channel<<SP::Target as SignerProvider>::Signer>
6534                 where
6535                         ES::Target: EntropySource,
6536                         SP::Target: SignerProvider
6537 {
6538         fn read<R : io::Read>(reader: &mut R, args: (&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)) -> Result<Self, DecodeError> {
6539                 let (entropy_source, signer_provider, serialized_height, our_supported_features) = args;
6540                 let ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
6541
6542                 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6543                 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We read
6544                 // the low bytes now and the high bytes later.
6545                 let user_id_low: u64 = Readable::read(reader)?;
6546
6547                 let mut config = Some(LegacyChannelConfig::default());
6548                 if ver == 1 {
6549                         // Read the old serialization of the ChannelConfig from version 0.0.98.
6550                         config.as_mut().unwrap().options.forwarding_fee_proportional_millionths = Readable::read(reader)?;
6551                         config.as_mut().unwrap().options.cltv_expiry_delta = Readable::read(reader)?;
6552                         config.as_mut().unwrap().announced_channel = Readable::read(reader)?;
6553                         config.as_mut().unwrap().commit_upfront_shutdown_pubkey = Readable::read(reader)?;
6554                 } else {
6555                         // Read the 8 bytes of backwards-compatibility ChannelConfig data.
6556                         let mut _val: u64 = Readable::read(reader)?;
6557                 }
6558
6559                 let channel_id = Readable::read(reader)?;
6560                 let channel_state = Readable::read(reader)?;
6561                 let channel_value_satoshis = Readable::read(reader)?;
6562
6563                 let latest_monitor_update_id = Readable::read(reader)?;
6564
6565                 let mut keys_data = None;
6566                 if ver <= 2 {
6567                         // Read the serialize signer bytes. We'll choose to deserialize them or not based on whether
6568                         // the `channel_keys_id` TLV is present below.
6569                         let keys_len: u32 = Readable::read(reader)?;
6570                         keys_data = Some(Vec::with_capacity(cmp::min(keys_len as usize, MAX_ALLOC_SIZE)));
6571                         while keys_data.as_ref().unwrap().len() != keys_len as usize {
6572                                 // Read 1KB at a time to avoid accidentally allocating 4GB on corrupted channel keys
6573                                 let mut data = [0; 1024];
6574                                 let read_slice = &mut data[0..cmp::min(1024, keys_len as usize - keys_data.as_ref().unwrap().len())];
6575                                 reader.read_exact(read_slice)?;
6576                                 keys_data.as_mut().unwrap().extend_from_slice(read_slice);
6577                         }
6578                 }
6579
6580                 // Read the old serialization for shutdown_pubkey, preferring the TLV field later if set.
6581                 let mut shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
6582                         Ok(pubkey) => Some(ShutdownScript::new_p2wpkh_from_pubkey(pubkey)),
6583                         Err(_) => None,
6584                 };
6585                 let destination_script = Readable::read(reader)?;
6586
6587                 let cur_holder_commitment_transaction_number = Readable::read(reader)?;
6588                 let cur_counterparty_commitment_transaction_number = Readable::read(reader)?;
6589                 let value_to_self_msat = Readable::read(reader)?;
6590
6591                 let pending_inbound_htlc_count: u64 = Readable::read(reader)?;
6592                 let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(pending_inbound_htlc_count as usize, OUR_MAX_HTLCS as usize));
6593                 for _ in 0..pending_inbound_htlc_count {
6594                         pending_inbound_htlcs.push(InboundHTLCOutput {
6595                                 htlc_id: Readable::read(reader)?,
6596                                 amount_msat: Readable::read(reader)?,
6597                                 cltv_expiry: Readable::read(reader)?,
6598                                 payment_hash: Readable::read(reader)?,
6599                                 state: match <u8 as Readable>::read(reader)? {
6600                                         1 => InboundHTLCState::AwaitingRemoteRevokeToAnnounce(Readable::read(reader)?),
6601                                         2 => InboundHTLCState::AwaitingAnnouncedRemoteRevoke(Readable::read(reader)?),
6602                                         3 => InboundHTLCState::Committed,
6603                                         4 => InboundHTLCState::LocalRemoved(Readable::read(reader)?),
6604                                         _ => return Err(DecodeError::InvalidValue),
6605                                 },
6606                         });
6607                 }
6608
6609                 let pending_outbound_htlc_count: u64 = Readable::read(reader)?;
6610                 let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(pending_outbound_htlc_count as usize, OUR_MAX_HTLCS as usize));
6611                 for _ in 0..pending_outbound_htlc_count {
6612                         pending_outbound_htlcs.push(OutboundHTLCOutput {
6613                                 htlc_id: Readable::read(reader)?,
6614                                 amount_msat: Readable::read(reader)?,
6615                                 cltv_expiry: Readable::read(reader)?,
6616                                 payment_hash: Readable::read(reader)?,
6617                                 source: Readable::read(reader)?,
6618                                 state: match <u8 as Readable>::read(reader)? {
6619                                         0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
6620                                         1 => OutboundHTLCState::Committed,
6621                                         2 => {
6622                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6623                                                 OutboundHTLCState::RemoteRemoved(option.into())
6624                                         },
6625                                         3 => {
6626                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6627                                                 OutboundHTLCState::AwaitingRemoteRevokeToRemove(option.into())
6628                                         },
6629                                         4 => {
6630                                                 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6631                                                 OutboundHTLCState::AwaitingRemovedRemoteRevoke(option.into())
6632                                         },
6633                                         _ => return Err(DecodeError::InvalidValue),
6634                                 },
6635                         });
6636                 }
6637
6638                 let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
6639                 let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, OUR_MAX_HTLCS as usize*2));
6640                 for _ in 0..holding_cell_htlc_update_count {
6641                         holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
6642                                 0 => HTLCUpdateAwaitingACK::AddHTLC {
6643                                         amount_msat: Readable::read(reader)?,
6644                                         cltv_expiry: Readable::read(reader)?,
6645                                         payment_hash: Readable::read(reader)?,
6646                                         source: Readable::read(reader)?,
6647                                         onion_routing_packet: Readable::read(reader)?,
6648                                 },
6649                                 1 => HTLCUpdateAwaitingACK::ClaimHTLC {
6650                                         payment_preimage: Readable::read(reader)?,
6651                                         htlc_id: Readable::read(reader)?,
6652                                 },
6653                                 2 => HTLCUpdateAwaitingACK::FailHTLC {
6654                                         htlc_id: Readable::read(reader)?,
6655                                         err_packet: Readable::read(reader)?,
6656                                 },
6657                                 _ => return Err(DecodeError::InvalidValue),
6658                         });
6659                 }
6660
6661                 let resend_order = match <u8 as Readable>::read(reader)? {
6662                         0 => RAACommitmentOrder::CommitmentFirst,
6663                         1 => RAACommitmentOrder::RevokeAndACKFirst,
6664                         _ => return Err(DecodeError::InvalidValue),
6665                 };
6666
6667                 let monitor_pending_channel_ready = Readable::read(reader)?;
6668                 let monitor_pending_revoke_and_ack = Readable::read(reader)?;
6669                 let monitor_pending_commitment_signed = Readable::read(reader)?;
6670
6671                 let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
6672                 let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, OUR_MAX_HTLCS as usize));
6673                 for _ in 0..monitor_pending_forwards_count {
6674                         monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
6675                 }
6676
6677                 let monitor_pending_failures_count: u64 = Readable::read(reader)?;
6678                 let mut monitor_pending_failures = Vec::with_capacity(cmp::min(monitor_pending_failures_count as usize, OUR_MAX_HTLCS as usize));
6679                 for _ in 0..monitor_pending_failures_count {
6680                         monitor_pending_failures.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
6681                 }
6682
6683                 let pending_update_fee_value: Option<u32> = Readable::read(reader)?;
6684
6685                 let holding_cell_update_fee = Readable::read(reader)?;
6686
6687                 let next_holder_htlc_id = Readable::read(reader)?;
6688                 let next_counterparty_htlc_id = Readable::read(reader)?;
6689                 let update_time_counter = Readable::read(reader)?;
6690                 let feerate_per_kw = Readable::read(reader)?;
6691
6692                 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
6693                 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
6694                 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
6695                 // consider the stale state on reload.
6696                 match <u8 as Readable>::read(reader)? {
6697                         0 => {},
6698                         1 => {
6699                                 let _: u32 = Readable::read(reader)?;
6700                                 let _: u64 = Readable::read(reader)?;
6701                                 let _: Signature = Readable::read(reader)?;
6702                         },
6703                         _ => return Err(DecodeError::InvalidValue),
6704                 }
6705
6706                 let funding_tx_confirmed_in = Readable::read(reader)?;
6707                 let funding_tx_confirmation_height = Readable::read(reader)?;
6708                 let short_channel_id = Readable::read(reader)?;
6709
6710                 let counterparty_dust_limit_satoshis = Readable::read(reader)?;
6711                 let holder_dust_limit_satoshis = Readable::read(reader)?;
6712                 let counterparty_max_htlc_value_in_flight_msat = Readable::read(reader)?;
6713                 let mut counterparty_selected_channel_reserve_satoshis = None;
6714                 if ver == 1 {
6715                         // Read the old serialization from version 0.0.98.
6716                         counterparty_selected_channel_reserve_satoshis = Some(Readable::read(reader)?);
6717                 } else {
6718                         // Read the 8 bytes of backwards-compatibility data.
6719                         let _dummy: u64 = Readable::read(reader)?;
6720                 }
6721                 let counterparty_htlc_minimum_msat = Readable::read(reader)?;
6722                 let holder_htlc_minimum_msat = Readable::read(reader)?;
6723                 let counterparty_max_accepted_htlcs = Readable::read(reader)?;
6724
6725                 let mut minimum_depth = None;
6726                 if ver == 1 {
6727                         // Read the old serialization from version 0.0.98.
6728                         minimum_depth = Some(Readable::read(reader)?);
6729                 } else {
6730                         // Read the 4 bytes of backwards-compatibility data.
6731                         let _dummy: u32 = Readable::read(reader)?;
6732                 }
6733
6734                 let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
6735                         0 => None,
6736                         1 => Some(CounterpartyForwardingInfo {
6737                                 fee_base_msat: Readable::read(reader)?,
6738                                 fee_proportional_millionths: Readable::read(reader)?,
6739                                 cltv_expiry_delta: Readable::read(reader)?,
6740                         }),
6741                         _ => return Err(DecodeError::InvalidValue),
6742                 };
6743
6744                 let channel_parameters: ChannelTransactionParameters = Readable::read(reader)?;
6745                 let funding_transaction = Readable::read(reader)?;
6746
6747                 let counterparty_cur_commitment_point = Readable::read(reader)?;
6748
6749                 let counterparty_prev_commitment_point = Readable::read(reader)?;
6750                 let counterparty_node_id = Readable::read(reader)?;
6751
6752                 let counterparty_shutdown_scriptpubkey = Readable::read(reader)?;
6753                 let commitment_secrets = Readable::read(reader)?;
6754
6755                 let channel_update_status = Readable::read(reader)?;
6756
6757                 #[cfg(any(test, fuzzing))]
6758                 let mut historical_inbound_htlc_fulfills = HashSet::new();
6759                 #[cfg(any(test, fuzzing))]
6760                 {
6761                         let htlc_fulfills_len: u64 = Readable::read(reader)?;
6762                         for _ in 0..htlc_fulfills_len {
6763                                 assert!(historical_inbound_htlc_fulfills.insert(Readable::read(reader)?));
6764                         }
6765                 }
6766
6767                 let pending_update_fee = if let Some(feerate) = pending_update_fee_value {
6768                         Some((feerate, if channel_parameters.is_outbound_from_holder {
6769                                 FeeUpdateState::Outbound
6770                         } else {
6771                                 FeeUpdateState::AwaitingRemoteRevokeToAnnounce
6772                         }))
6773                 } else {
6774                         None
6775                 };
6776
6777                 let mut announcement_sigs = None;
6778                 let mut target_closing_feerate_sats_per_kw = None;
6779                 let mut monitor_pending_finalized_fulfills = Some(Vec::new());
6780                 let mut holder_selected_channel_reserve_satoshis = Some(Self::get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis));
6781                 let mut holder_max_htlc_value_in_flight_msat = Some(Self::get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &UserConfig::default().channel_handshake_config));
6782                 // Prior to supporting channel type negotiation, all of our channels were static_remotekey
6783                 // only, so we default to that if none was written.
6784                 let mut channel_type = Some(ChannelTypeFeatures::only_static_remote_key());
6785                 let mut channel_creation_height = Some(serialized_height);
6786                 let mut preimages_opt: Option<Vec<Option<PaymentPreimage>>> = None;
6787
6788                 // If we read an old Channel, for simplicity we just treat it as "we never sent an
6789                 // AnnouncementSignatures" which implies we'll re-send it on reconnect, but that's fine.
6790                 let mut announcement_sigs_state = Some(AnnouncementSigsState::NotSent);
6791                 let mut latest_inbound_scid_alias = None;
6792                 let mut outbound_scid_alias = None;
6793                 let mut channel_pending_event_emitted = None;
6794                 let mut channel_ready_event_emitted = None;
6795
6796                 let mut user_id_high_opt: Option<u64> = None;
6797                 let mut channel_keys_id: Option<[u8; 32]> = None;
6798                 let mut temporary_channel_id: Option<[u8; 32]> = None;
6799
6800                 read_tlv_fields!(reader, {
6801                         (0, announcement_sigs, option),
6802                         (1, minimum_depth, option),
6803                         (2, channel_type, option),
6804                         (3, counterparty_selected_channel_reserve_satoshis, option),
6805                         (4, holder_selected_channel_reserve_satoshis, option),
6806                         (5, config, option), // Note that if none is provided we will *not* overwrite the existing one.
6807                         (6, holder_max_htlc_value_in_flight_msat, option),
6808                         (7, shutdown_scriptpubkey, option),
6809                         (9, target_closing_feerate_sats_per_kw, option),
6810                         (11, monitor_pending_finalized_fulfills, vec_type),
6811                         (13, channel_creation_height, option),
6812                         (15, preimages_opt, vec_type),
6813                         (17, announcement_sigs_state, option),
6814                         (19, latest_inbound_scid_alias, option),
6815                         (21, outbound_scid_alias, option),
6816                         (23, channel_ready_event_emitted, option),
6817                         (25, user_id_high_opt, option),
6818                         (27, channel_keys_id, option),
6819                         (29, temporary_channel_id, option),
6820                         (31, channel_pending_event_emitted, option),
6821                 });
6822
6823                 let (channel_keys_id, holder_signer) = if let Some(channel_keys_id) = channel_keys_id {
6824                         let mut holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
6825                         // If we've gotten to the funding stage of the channel, populate the signer with its
6826                         // required channel parameters.
6827                         let non_shutdown_state = channel_state & (!MULTI_STATE_FLAGS);
6828                         if non_shutdown_state >= (ChannelState::FundingCreated as u32) {
6829                                 holder_signer.provide_channel_parameters(&channel_parameters);
6830                         }
6831                         (channel_keys_id, holder_signer)
6832                 } else {
6833                         // `keys_data` can be `None` if we had corrupted data.
6834                         let keys_data = keys_data.ok_or(DecodeError::InvalidValue)?;
6835                         let holder_signer = signer_provider.read_chan_signer(&keys_data)?;
6836                         (holder_signer.channel_keys_id(), holder_signer)
6837                 };
6838
6839                 if let Some(preimages) = preimages_opt {
6840                         let mut iter = preimages.into_iter();
6841                         for htlc in pending_outbound_htlcs.iter_mut() {
6842                                 match &htlc.state {
6843                                         OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(None)) => {
6844                                                 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
6845                                         }
6846                                         OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(None)) => {
6847                                                 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
6848                                         }
6849                                         _ => {}
6850                                 }
6851                         }
6852                         // We expect all preimages to be consumed above
6853                         if iter.next().is_some() {
6854                                 return Err(DecodeError::InvalidValue);
6855                         }
6856                 }
6857
6858                 let chan_features = channel_type.as_ref().unwrap();
6859                 if !chan_features.is_subset(our_supported_features) {
6860                         // If the channel was written by a new version and negotiated with features we don't
6861                         // understand yet, refuse to read it.
6862                         return Err(DecodeError::UnknownRequiredFeature);
6863                 }
6864
6865                 let mut secp_ctx = Secp256k1::new();
6866                 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
6867
6868                 // `user_id` used to be a single u64 value. In order to remain backwards
6869                 // compatible with versions prior to 0.0.113, the u128 is serialized as two
6870                 // separate u64 values.
6871                 let user_id = user_id_low as u128 + ((user_id_high_opt.unwrap_or(0) as u128) << 64);
6872
6873                 Ok(Channel {
6874                         user_id,
6875
6876                         config: config.unwrap(),
6877
6878                         prev_config: None,
6879
6880                         // Note that we don't care about serializing handshake limits as we only ever serialize
6881                         // channel data after the handshake has completed.
6882                         inbound_handshake_limits_override: None,
6883
6884                         channel_id,
6885                         temporary_channel_id,
6886                         channel_state,
6887                         announcement_sigs_state: announcement_sigs_state.unwrap(),
6888                         secp_ctx,
6889                         channel_value_satoshis,
6890
6891                         latest_monitor_update_id,
6892
6893                         holder_signer,
6894                         shutdown_scriptpubkey,
6895                         destination_script,
6896
6897                         cur_holder_commitment_transaction_number,
6898                         cur_counterparty_commitment_transaction_number,
6899                         value_to_self_msat,
6900
6901                         pending_inbound_htlcs,
6902                         pending_outbound_htlcs,
6903                         holding_cell_htlc_updates,
6904
6905                         resend_order,
6906
6907                         monitor_pending_channel_ready,
6908                         monitor_pending_revoke_and_ack,
6909                         monitor_pending_commitment_signed,
6910                         monitor_pending_forwards,
6911                         monitor_pending_failures,
6912                         monitor_pending_finalized_fulfills: monitor_pending_finalized_fulfills.unwrap(),
6913
6914                         pending_update_fee,
6915                         holding_cell_update_fee,
6916                         next_holder_htlc_id,
6917                         next_counterparty_htlc_id,
6918                         update_time_counter,
6919                         feerate_per_kw,
6920
6921                         #[cfg(debug_assertions)]
6922                         holder_max_commitment_tx_output: Mutex::new((0, 0)),
6923                         #[cfg(debug_assertions)]
6924                         counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
6925
6926                         last_sent_closing_fee: None,
6927                         pending_counterparty_closing_signed: None,
6928                         closing_fee_limits: None,
6929                         target_closing_feerate_sats_per_kw,
6930
6931                         inbound_awaiting_accept: false,
6932
6933                         funding_tx_confirmed_in,
6934                         funding_tx_confirmation_height,
6935                         short_channel_id,
6936                         channel_creation_height: channel_creation_height.unwrap(),
6937
6938                         counterparty_dust_limit_satoshis,
6939                         holder_dust_limit_satoshis,
6940                         counterparty_max_htlc_value_in_flight_msat,
6941                         holder_max_htlc_value_in_flight_msat: holder_max_htlc_value_in_flight_msat.unwrap(),
6942                         counterparty_selected_channel_reserve_satoshis,
6943                         holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.unwrap(),
6944                         counterparty_htlc_minimum_msat,
6945                         holder_htlc_minimum_msat,
6946                         counterparty_max_accepted_htlcs,
6947                         minimum_depth,
6948
6949                         counterparty_forwarding_info,
6950
6951                         channel_transaction_parameters: channel_parameters,
6952                         funding_transaction,
6953
6954                         counterparty_cur_commitment_point,
6955                         counterparty_prev_commitment_point,
6956                         counterparty_node_id,
6957
6958                         counterparty_shutdown_scriptpubkey,
6959
6960                         commitment_secrets,
6961
6962                         channel_update_status,
6963                         closing_signed_in_flight: false,
6964
6965                         announcement_sigs,
6966
6967                         #[cfg(any(test, fuzzing))]
6968                         next_local_commitment_tx_fee_info_cached: Mutex::new(None),
6969                         #[cfg(any(test, fuzzing))]
6970                         next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
6971
6972                         workaround_lnd_bug_4006: None,
6973
6974                         latest_inbound_scid_alias,
6975                         // Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
6976                         outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
6977
6978                         channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
6979                         channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
6980
6981                         #[cfg(any(test, fuzzing))]
6982                         historical_inbound_htlc_fulfills,
6983
6984                         channel_type: channel_type.unwrap(),
6985                         channel_keys_id,
6986
6987                         pending_monitor_updates: Vec::new(),
6988                 })
6989         }
6990 }
6991
6992 #[cfg(test)]
6993 mod tests {
6994         use std::cmp;
6995         use bitcoin::blockdata::script::{Script, Builder};
6996         use bitcoin::blockdata::transaction::{Transaction, TxOut};
6997         use bitcoin::blockdata::constants::genesis_block;
6998         use bitcoin::blockdata::opcodes;
6999         use bitcoin::network::constants::Network;
7000         use hex;
7001         use crate::ln::PaymentHash;
7002         use crate::ln::channelmanager::{self, HTLCSource, PaymentId};
7003         #[cfg(anchors)]
7004         use crate::ln::channel::InitFeatures;
7005         use crate::ln::channel::{Channel, InboundHTLCOutput, OutboundHTLCOutput, InboundHTLCState, OutboundHTLCState, HTLCCandidate, HTLCInitiator};
7006         use crate::ln::channel::{MAX_FUNDING_SATOSHIS_NO_WUMBO, TOTAL_BITCOIN_SUPPLY_SATOSHIS, MIN_THEIR_CHAN_RESERVE_SATOSHIS};
7007         use crate::ln::features::ChannelTypeFeatures;
7008         use crate::ln::msgs::{ChannelUpdate, DataLossProtect, DecodeError, OptionalField, UnsignedChannelUpdate, MAX_VALUE_MSAT};
7009         use crate::ln::script::ShutdownScript;
7010         use crate::ln::chan_utils;
7011         use crate::ln::chan_utils::{htlc_success_tx_weight, htlc_timeout_tx_weight};
7012         use crate::chain::BestBlock;
7013         use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
7014         use crate::chain::keysinterface::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
7015         use crate::chain::transaction::OutPoint;
7016         use crate::util::config::UserConfig;
7017         use crate::util::enforcing_trait_impls::EnforcingSigner;
7018         use crate::util::errors::APIError;
7019         use crate::util::test_utils;
7020         use crate::util::test_utils::OnGetShutdownScriptpubkey;
7021         use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
7022         use bitcoin::secp256k1::ffi::Signature as FFISignature;
7023         use bitcoin::secp256k1::{SecretKey,PublicKey};
7024         use bitcoin::hashes::sha256::Hash as Sha256;
7025         use bitcoin::hashes::Hash;
7026         use bitcoin::hash_types::WPubkeyHash;
7027         use bitcoin::PackedLockTime;
7028         use bitcoin::util::address::WitnessVersion;
7029         use crate::prelude::*;
7030
7031         struct TestFeeEstimator {
7032                 fee_est: u32
7033         }
7034         impl FeeEstimator for TestFeeEstimator {
7035                 fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
7036                         self.fee_est
7037                 }
7038         }
7039
7040         #[test]
7041         fn test_max_funding_satoshis_no_wumbo() {
7042                 assert_eq!(TOTAL_BITCOIN_SUPPLY_SATOSHIS, 21_000_000 * 100_000_000);
7043                 assert!(MAX_FUNDING_SATOSHIS_NO_WUMBO <= TOTAL_BITCOIN_SUPPLY_SATOSHIS,
7044                         "MAX_FUNDING_SATOSHIS_NO_WUMBO is greater than all satoshis in existence");
7045         }
7046
7047         #[test]
7048         fn test_no_fee_check_overflow() {
7049                 // Previously, calling `check_remote_fee` with a fee of 0xffffffff would overflow in
7050                 // arithmetic, causing a panic with debug assertions enabled.
7051                 let fee_est = TestFeeEstimator { fee_est: 42 };
7052                 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
7053                 assert!(Channel::<InMemorySigner>::check_remote_fee(&bounded_fee_estimator,
7054                         u32::max_value(), None, &&test_utils::TestLogger::new()).is_err());
7055         }
7056
7057         struct Keys {
7058                 signer: InMemorySigner,
7059         }
7060
7061         impl EntropySource for Keys {
7062                 fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }
7063         }
7064
7065         impl SignerProvider for Keys {
7066                 type Signer = InMemorySigner;
7067
7068                 fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
7069                         self.signer.channel_keys_id()
7070                 }
7071
7072                 fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::Signer {
7073                         self.signer.clone()
7074                 }
7075
7076                 fn read_chan_signer(&self, _data: &[u8]) -> Result<Self::Signer, DecodeError> { panic!(); }
7077
7078                 fn get_destination_script(&self) -> Script {
7079                         let secp_ctx = Secp256k1::signing_only();
7080                         let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
7081                         let channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
7082                         Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&channel_monitor_claim_key_hash[..]).into_script()
7083                 }
7084
7085                 fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
7086                         let secp_ctx = Secp256k1::signing_only();
7087                         let channel_close_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
7088                         ShutdownScript::new_p2wpkh_from_pubkey(PublicKey::from_secret_key(&secp_ctx, &channel_close_key))
7089                 }
7090         }
7091
7092         #[cfg(not(feature = "grind_signatures"))]
7093         fn public_from_secret_hex(secp_ctx: &Secp256k1<bitcoin::secp256k1::All>, hex: &str) -> PublicKey {
7094                 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode(hex).unwrap()[..]).unwrap())
7095         }
7096
7097         #[test]
7098         fn upfront_shutdown_script_incompatibility() {
7099                 let features = channelmanager::provided_init_features(&UserConfig::default()).clear_shutdown_anysegwit();
7100                 let non_v0_segwit_shutdown_script =
7101                         ShutdownScript::new_witness_program(WitnessVersion::V16, &[0, 40]).unwrap();
7102
7103                 let seed = [42; 32];
7104                 let network = Network::Testnet;
7105                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7106                 keys_provider.expect(OnGetShutdownScriptpubkey {
7107                         returns: non_v0_segwit_shutdown_script.clone(),
7108                 });
7109
7110                 let secp_ctx = Secp256k1::new();
7111                 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7112                 let config = UserConfig::default();
7113                 match Channel::<EnforcingSigner>::new_outbound(&LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 253 }), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42) {
7114                         Err(APIError::IncompatibleShutdownScript { script }) => {
7115                                 assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
7116                         },
7117                         Err(e) => panic!("Unexpected error: {:?}", e),
7118                         Ok(_) => panic!("Expected error"),
7119                 }
7120         }
7121
7122         // Check that, during channel creation, we use the same feerate in the open channel message
7123         // as we do in the Channel object creation itself.
7124         #[test]
7125         fn test_open_channel_msg_fee() {
7126                 let original_fee = 253;
7127                 let mut fee_est = TestFeeEstimator{fee_est: original_fee };
7128                 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
7129                 let secp_ctx = Secp256k1::new();
7130                 let seed = [42; 32];
7131                 let network = Network::Testnet;
7132                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7133
7134                 let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7135                 let config = UserConfig::default();
7136                 let node_a_chan = Channel::<EnforcingSigner>::new_outbound(&bounded_fee_estimator, &&keys_provider, &&keys_provider, node_a_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7137
7138                 // Now change the fee so we can check that the fee in the open_channel message is the
7139                 // same as the old fee.
7140                 fee_est.fee_est = 500;
7141                 let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
7142                 assert_eq!(open_channel_msg.feerate_per_kw, original_fee);
7143         }
7144
7145         #[test]
7146         fn test_holder_vs_counterparty_dust_limit() {
7147                 // Test that when calculating the local and remote commitment transaction fees, the correct
7148                 // dust limits are used.
7149                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7150                 let secp_ctx = Secp256k1::new();
7151                 let seed = [42; 32];
7152                 let network = Network::Testnet;
7153                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7154                 let logger = test_utils::TestLogger::new();
7155
7156                 // Go through the flow of opening a channel between two nodes, making sure
7157                 // they have different dust limits.
7158
7159                 // Create Node A's channel pointing to Node B's pubkey
7160                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7161                 let config = UserConfig::default();
7162                 let mut node_a_chan = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7163
7164                 // Create Node B's channel by receiving Node A's open_channel message
7165                 // Make sure A's dust limit is as we expect.
7166                 let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
7167                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7168                 let mut node_b_chan = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7169
7170                 // Node B --> Node A: accept channel, explicitly setting B's dust limit.
7171                 let mut accept_channel_msg = node_b_chan.accept_inbound_channel(0);
7172                 accept_channel_msg.dust_limit_satoshis = 546;
7173                 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
7174                 node_a_chan.holder_dust_limit_satoshis = 1560;
7175
7176                 // Put some inbound and outbound HTLCs in A's channel.
7177                 let htlc_amount_msat = 11_092_000; // put an amount below A's effective dust limit but above B's.
7178                 node_a_chan.pending_inbound_htlcs.push(InboundHTLCOutput {
7179                         htlc_id: 0,
7180                         amount_msat: htlc_amount_msat,
7181                         payment_hash: PaymentHash(Sha256::hash(&[42; 32]).into_inner()),
7182                         cltv_expiry: 300000000,
7183                         state: InboundHTLCState::Committed,
7184                 });
7185
7186                 node_a_chan.pending_outbound_htlcs.push(OutboundHTLCOutput {
7187                         htlc_id: 1,
7188                         amount_msat: htlc_amount_msat, // put an amount below A's dust amount but above B's.
7189                         payment_hash: PaymentHash(Sha256::hash(&[43; 32]).into_inner()),
7190                         cltv_expiry: 200000000,
7191                         state: OutboundHTLCState::Committed,
7192                         source: HTLCSource::OutboundRoute {
7193                                 path: Vec::new(),
7194                                 session_priv: SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
7195                                 first_hop_htlc_msat: 548,
7196                                 payment_id: PaymentId([42; 32]),
7197                         }
7198                 });
7199
7200                 // Make sure when Node A calculates their local commitment transaction, none of the HTLCs pass
7201                 // the dust limit check.
7202                 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
7203                 let local_commit_tx_fee = node_a_chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
7204                 let local_commit_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.feerate_per_kw, 0, node_a_chan.opt_anchors());
7205                 assert_eq!(local_commit_tx_fee, local_commit_fee_0_htlcs);
7206
7207                 // Finally, make sure that when Node A calculates the remote's commitment transaction fees, all
7208                 // of the HTLCs are seen to be above the dust limit.
7209                 node_a_chan.channel_transaction_parameters.is_outbound_from_holder = false;
7210                 let remote_commit_fee_3_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.feerate_per_kw, 3, node_a_chan.opt_anchors());
7211                 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
7212                 let remote_commit_tx_fee = node_a_chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7213                 assert_eq!(remote_commit_tx_fee, remote_commit_fee_3_htlcs);
7214         }
7215
7216         #[test]
7217         fn test_timeout_vs_success_htlc_dust_limit() {
7218                 // Make sure that when `next_remote_commit_tx_fee_msat` and `next_local_commit_tx_fee_msat`
7219                 // calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
7220                 // *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
7221                 // `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
7222                 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 253 });
7223                 let secp_ctx = Secp256k1::new();
7224                 let seed = [42; 32];
7225                 let network = Network::Testnet;
7226                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7227
7228                 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7229                 let config = UserConfig::default();
7230                 let mut chan = Channel::<EnforcingSigner>::new_outbound(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7231
7232                 let commitment_tx_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.feerate_per_kw, 0, chan.opt_anchors());
7233                 let commitment_tx_fee_1_htlc = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.feerate_per_kw, 1, chan.opt_anchors());
7234
7235                 // If HTLC_SUCCESS_TX_WEIGHT and HTLC_TIMEOUT_TX_WEIGHT were swapped: then this HTLC would be
7236                 // counted as dust when it shouldn't be.
7237                 let htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.holder_dust_limit_satoshis + 1) * 1000;
7238                 let htlc_candidate = HTLCCandidate::new(htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
7239                 let commitment_tx_fee = chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
7240                 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
7241
7242                 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
7243                 let dust_htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.holder_dust_limit_satoshis - 1) * 1000;
7244                 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_below_success, HTLCInitiator::RemoteOffered);
7245                 let commitment_tx_fee = chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
7246                 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
7247
7248                 chan.channel_transaction_parameters.is_outbound_from_holder = false;
7249
7250                 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
7251                 let dust_htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.counterparty_dust_limit_satoshis + 1) * 1000;
7252                 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
7253                 let commitment_tx_fee = chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7254                 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
7255
7256                 // If swapped: this HTLC would be counted as dust when it shouldn't be.
7257                 let htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.counterparty_dust_limit_satoshis - 1) * 1000;
7258                 let htlc_candidate = HTLCCandidate::new(htlc_amt_below_success, HTLCInitiator::RemoteOffered);
7259                 let commitment_tx_fee = chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7260                 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
7261         }
7262
7263         #[test]
7264         fn channel_reestablish_no_updates() {
7265                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7266                 let logger = test_utils::TestLogger::new();
7267                 let secp_ctx = Secp256k1::new();
7268                 let seed = [42; 32];
7269                 let network = Network::Testnet;
7270                 let best_block = BestBlock::from_network(network);
7271                 let chain_hash = best_block.block_hash();
7272                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7273
7274                 // Go through the flow of opening a channel between two nodes.
7275
7276                 // Create Node A's channel pointing to Node B's pubkey
7277                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7278                 let config = UserConfig::default();
7279                 let mut node_a_chan = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7280
7281                 // Create Node B's channel by receiving Node A's open_channel message
7282                 let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
7283                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7284                 let mut node_b_chan = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7285
7286                 // Node B --> Node A: accept channel
7287                 let accept_channel_msg = node_b_chan.accept_inbound_channel(0);
7288                 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
7289
7290                 // Node A --> Node B: funding created
7291                 let output_script = node_a_chan.get_funding_redeemscript();
7292                 let tx = Transaction { version: 1, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: vec![TxOut {
7293                         value: 10000000, script_pubkey: output_script.clone(),
7294                 }]};
7295                 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
7296                 let funding_created_msg = node_a_chan.get_outbound_funding_created(tx.clone(), funding_outpoint, &&logger).unwrap();
7297                 let (funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg, best_block, &&keys_provider, &&logger).unwrap();
7298
7299                 // Node B --> Node A: funding signed
7300                 let _ = node_a_chan.funding_signed(&funding_signed_msg, best_block, &&keys_provider, &&logger);
7301
7302                 // Now disconnect the two nodes and check that the commitment point in
7303                 // Node B's channel_reestablish message is sane.
7304                 node_b_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger);
7305                 let msg = node_b_chan.get_channel_reestablish(&&logger);
7306                 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
7307                 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
7308                 match msg.data_loss_protect {
7309                         OptionalField::Present(DataLossProtect { your_last_per_commitment_secret, .. }) => {
7310                                 assert_eq!(your_last_per_commitment_secret, [0; 32]);
7311                         },
7312                         _ => panic!()
7313                 }
7314
7315                 // Check that the commitment point in Node A's channel_reestablish message
7316                 // is sane.
7317                 node_a_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger);
7318                 let msg = node_a_chan.get_channel_reestablish(&&logger);
7319                 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
7320                 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
7321                 match msg.data_loss_protect {
7322                         OptionalField::Present(DataLossProtect { your_last_per_commitment_secret, .. }) => {
7323                                 assert_eq!(your_last_per_commitment_secret, [0; 32]);
7324                         },
7325                         _ => panic!()
7326                 }
7327         }
7328
7329         #[test]
7330         fn test_configured_holder_max_htlc_value_in_flight() {
7331                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7332                 let logger = test_utils::TestLogger::new();
7333                 let secp_ctx = Secp256k1::new();
7334                 let seed = [42; 32];
7335                 let network = Network::Testnet;
7336                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7337                 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7338                 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7339
7340                 let mut config_2_percent = UserConfig::default();
7341                 config_2_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 2;
7342                 let mut config_99_percent = UserConfig::default();
7343                 config_99_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 99;
7344                 let mut config_0_percent = UserConfig::default();
7345                 config_0_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 0;
7346                 let mut config_101_percent = UserConfig::default();
7347                 config_101_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 101;
7348
7349                 // Test that `new_outbound` creates a channel with the correct value for
7350                 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
7351                 // which is set to the lower bound + 1 (2%) of the `channel_value`.
7352                 let chan_1 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42).unwrap();
7353                 let chan_1_value_msat = chan_1.channel_value_satoshis * 1000;
7354                 assert_eq!(chan_1.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
7355
7356                 // Test with the upper bound - 1 of valid values (99%).
7357                 let chan_2 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42).unwrap();
7358                 let chan_2_value_msat = chan_2.channel_value_satoshis * 1000;
7359                 assert_eq!(chan_2.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
7360
7361                 let chan_1_open_channel_msg = chan_1.get_open_channel(genesis_block(network).header.block_hash());
7362
7363                 // Test that `new_from_req` creates a channel with the correct value for
7364                 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
7365                 // which is set to the lower bound - 1 (2%) of the `channel_value`.
7366                 let chan_3 = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7367                 let chan_3_value_msat = chan_3.channel_value_satoshis * 1000;
7368                 assert_eq!(chan_3.holder_max_htlc_value_in_flight_msat, (chan_3_value_msat as f64 * 0.02) as u64);
7369
7370                 // Test with the upper bound - 1 of valid values (99%).
7371                 let chan_4 = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7372                 let chan_4_value_msat = chan_4.channel_value_satoshis * 1000;
7373                 assert_eq!(chan_4.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);
7374
7375                 // Test that `new_outbound` uses the lower bound of the configurable percentage values (1%)
7376                 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
7377                 let chan_5 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42).unwrap();
7378                 let chan_5_value_msat = chan_5.channel_value_satoshis * 1000;
7379                 assert_eq!(chan_5.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
7380
7381                 // Test that `new_outbound` uses the upper bound of the configurable percentage values
7382                 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
7383                 // than 100.
7384                 let chan_6 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42).unwrap();
7385                 let chan_6_value_msat = chan_6.channel_value_satoshis * 1000;
7386                 assert_eq!(chan_6.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
7387
7388                 // Test that `new_from_req` uses the lower bound of the configurable percentage values (1%)
7389                 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
7390                 let chan_7 = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7391                 let chan_7_value_msat = chan_7.channel_value_satoshis * 1000;
7392                 assert_eq!(chan_7.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);
7393
7394                 // Test that `new_from_req` uses the upper bound of the configurable percentage values
7395                 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
7396                 // than 100.
7397                 let chan_8 = Channel::<EnforcingSigner>::new_from_req(&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, 42).unwrap();
7398                 let chan_8_value_msat = chan_8.channel_value_satoshis * 1000;
7399                 assert_eq!(chan_8.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
7400         }
7401
7402         #[test]
7403         fn test_configured_holder_selected_channel_reserve_satoshis() {
7404
7405                 // Test that `new_outbound` and `new_from_req` create a channel with the correct
7406                 // channel reserves, when `their_channel_reserve_proportional_millionths` is configured.
7407                 test_self_and_counterparty_channel_reserve(10_000_000, 0.02, 0.02);
7408
7409                 // Test with valid but unreasonably high channel reserves
7410                 // Requesting and accepting parties have requested for 49%-49% and 60%-30% channel reserve
7411                 test_self_and_counterparty_channel_reserve(10_000_000, 0.49, 0.49);
7412                 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.30);
7413
7414                 // Test with calculated channel reserve less than lower bound
7415                 // i.e `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
7416                 test_self_and_counterparty_channel_reserve(100_000, 0.00002, 0.30);
7417
7418                 // Test with invalid channel reserves since sum of both is greater than or equal
7419                 // to channel value
7420                 test_self_and_counterparty_channel_reserve(10_000_000, 0.50, 0.50);
7421                 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.50);
7422         }
7423
7424         fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
7425                 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 15_000 });
7426                 let logger = test_utils::TestLogger::new();
7427                 let secp_ctx = Secp256k1::new();
7428                 let seed = [42; 32];
7429                 let network = Network::Testnet;
7430                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7431                 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7432                 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7433
7434
7435                 let mut outbound_node_config = UserConfig::default();
7436                 outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
7437                 let chan = Channel::<EnforcingSigner>::new_outbound(&&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).unwrap();
7438
7439                 let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64);
7440                 assert_eq!(chan.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
7441
7442                 let chan_open_channel_msg = chan.get_open_channel(genesis_block(network).header.block_hash());
7443                 let mut inbound_node_config = UserConfig::default();
7444                 inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
7445
7446                 if outbound_selected_channel_reserve_perc + inbound_selected_channel_reserve_perc < 1.0 {
7447                         let chan_inbound_node = Channel::<EnforcingSigner>::new_from_req(&&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, 42).unwrap();
7448
7449                         let expected_inbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.channel_value_satoshis as f64 * inbound_selected_channel_reserve_perc) as u64);
7450
7451                         assert_eq!(chan_inbound_node.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
7452                         assert_eq!(chan_inbound_node.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
7453                 } else {
7454                         // Channel Negotiations failed
7455                         let result = Channel::<EnforcingSigner>::new_from_req(&&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, 42);
7456                         assert!(result.is_err());
7457                 }
7458         }
7459
7460         #[test]
7461         fn channel_update() {
7462                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7463                 let secp_ctx = Secp256k1::new();
7464                 let seed = [42; 32];
7465                 let network = Network::Testnet;
7466                 let chain_hash = genesis_block(network).header.block_hash();
7467                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7468
7469                 // Create a channel.
7470                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7471                 let config = UserConfig::default();
7472                 let mut node_a_chan = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7473                 assert!(node_a_chan.counterparty_forwarding_info.is_none());
7474                 assert_eq!(node_a_chan.holder_htlc_minimum_msat, 1); // the default
7475                 assert!(node_a_chan.counterparty_forwarding_info().is_none());
7476
7477                 // Make sure that receiving a channel update will update the Channel as expected.
7478                 let update = ChannelUpdate {
7479                         contents: UnsignedChannelUpdate {
7480                                 chain_hash,
7481                                 short_channel_id: 0,
7482                                 timestamp: 0,
7483                                 flags: 0,
7484                                 cltv_expiry_delta: 100,
7485                                 htlc_minimum_msat: 5,
7486                                 htlc_maximum_msat: MAX_VALUE_MSAT,
7487                                 fee_base_msat: 110,
7488                                 fee_proportional_millionths: 11,
7489                                 excess_data: Vec::new(),
7490                         },
7491                         signature: Signature::from(unsafe { FFISignature::new() })
7492                 };
7493                 node_a_chan.channel_update(&update).unwrap();
7494
7495                 // The counterparty can send an update with a higher minimum HTLC, but that shouldn't
7496                 // change our official htlc_minimum_msat.
7497                 assert_eq!(node_a_chan.holder_htlc_minimum_msat, 1);
7498                 match node_a_chan.counterparty_forwarding_info() {
7499                         Some(info) => {
7500                                 assert_eq!(info.cltv_expiry_delta, 100);
7501                                 assert_eq!(info.fee_base_msat, 110);
7502                                 assert_eq!(info.fee_proportional_millionths, 11);
7503                         },
7504                         None => panic!("expected counterparty forwarding info to be Some")
7505                 }
7506         }
7507
7508         #[cfg(not(feature = "grind_signatures"))]
7509         #[test]
7510         fn outbound_commitment_test() {
7511                 use bitcoin::util::sighash;
7512                 use bitcoin::consensus::encode::serialize;
7513                 use bitcoin::blockdata::transaction::EcdsaSighashType;
7514                 use bitcoin::hashes::hex::FromHex;
7515                 use bitcoin::hash_types::Txid;
7516                 use bitcoin::secp256k1::Message;
7517                 use crate::chain::keysinterface::EcdsaChannelSigner;
7518                 use crate::ln::PaymentPreimage;
7519                 use crate::ln::channel::{HTLCOutputInCommitment ,TxCreationKeys};
7520                 use crate::ln::chan_utils::{ChannelPublicKeys, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters};
7521                 use crate::util::logger::Logger;
7522                 use crate::sync::Arc;
7523
7524                 // Test vectors from BOLT 3 Appendices C and F (anchors):
7525                 let feeest = TestFeeEstimator{fee_est: 15000};
7526                 let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
7527                 let secp_ctx = Secp256k1::new();
7528
7529                 let mut signer = InMemorySigner::new(
7530                         &secp_ctx,
7531                         SecretKey::from_slice(&hex::decode("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749").unwrap()[..]).unwrap(),
7532                         SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
7533                         SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
7534                         SecretKey::from_slice(&hex::decode("3333333333333333333333333333333333333333333333333333333333333333").unwrap()[..]).unwrap(),
7535                         SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
7536
7537                         // These aren't set in the test vectors:
7538                         [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],
7539                         10_000_000,
7540                         [0; 32],
7541                 );
7542
7543                 assert_eq!(signer.pubkeys().funding_pubkey.serialize()[..],
7544                                 hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
7545                 let keys_provider = Keys { signer: signer.clone() };
7546
7547                 let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7548                 let mut config = UserConfig::default();
7549                 config.channel_handshake_config.announced_channel = false;
7550                 let mut chan = Channel::<InMemorySigner>::new_outbound(&LowerBoundedFeeEstimator::new(&feeest), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42).unwrap(); // Nothing uses their network key in this test
7551                 chan.holder_dust_limit_satoshis = 546;
7552                 chan.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
7553
7554                 let funding_info = OutPoint{ txid: Txid::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), index: 0 };
7555
7556                 let counterparty_pubkeys = ChannelPublicKeys {
7557                         funding_pubkey: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
7558                         revocation_basepoint: PublicKey::from_slice(&hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap(),
7559                         payment_point: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"),
7560                         delayed_payment_basepoint: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
7561                         htlc_basepoint: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444")
7562                 };
7563                 chan.channel_transaction_parameters.counterparty_parameters = Some(
7564                         CounterpartyChannelTransactionParameters {
7565                                 pubkeys: counterparty_pubkeys.clone(),
7566                                 selected_contest_delay: 144
7567                         });
7568                 chan.channel_transaction_parameters.funding_outpoint = Some(funding_info);
7569                 signer.provide_channel_parameters(&chan.channel_transaction_parameters);
7570
7571                 assert_eq!(counterparty_pubkeys.payment_point.serialize()[..],
7572                            hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
7573
7574                 assert_eq!(counterparty_pubkeys.funding_pubkey.serialize()[..],
7575                            hex::decode("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1").unwrap()[..]);
7576
7577                 assert_eq!(counterparty_pubkeys.htlc_basepoint.serialize()[..],
7578                            hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
7579
7580                 // We can't just use build_holder_transaction_keys here as the per_commitment_secret is not
7581                 // derived from a commitment_seed, so instead we copy it here and call
7582                 // build_commitment_transaction.
7583                 let delayed_payment_base = &chan.holder_signer.pubkeys().delayed_payment_basepoint;
7584                 let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
7585                 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
7586                 let htlc_basepoint = &chan.holder_signer.pubkeys().htlc_basepoint;
7587                 let keys = TxCreationKeys::derive_new(&secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint);
7588
7589                 macro_rules! test_commitment {
7590                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
7591                                 chan.channel_transaction_parameters.opt_anchors = None;
7592                                 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, false, $($remain)*);
7593                         };
7594                 }
7595
7596                 macro_rules! test_commitment_with_anchors {
7597                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
7598                                 chan.channel_transaction_parameters.opt_anchors = Some(());
7599                                 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, true, $($remain)*);
7600                         };
7601                 }
7602
7603                 macro_rules! test_commitment_common {
7604                         ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $opt_anchors: expr, {
7605                                 $( { $htlc_idx: expr, $counterparty_htlc_sig_hex: expr, $htlc_sig_hex: expr, $htlc_tx_hex: expr } ), *
7606                         } ) => { {
7607                                 let (commitment_tx, htlcs): (_, Vec<HTLCOutputInCommitment>) = {
7608                                         let mut commitment_stats = chan.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false, &logger);
7609
7610                                         let htlcs = commitment_stats.htlcs_included.drain(..)
7611                                                 .filter_map(|(htlc, _)| if htlc.transaction_output_index.is_some() { Some(htlc) } else { None })
7612                                                 .collect();
7613                                         (commitment_stats.tx, htlcs)
7614                                 };
7615                                 let trusted_tx = commitment_tx.trust();
7616                                 let unsigned_tx = trusted_tx.built_transaction();
7617                                 let redeemscript = chan.get_funding_redeemscript();
7618                                 let counterparty_signature = Signature::from_der(&hex::decode($counterparty_sig_hex).unwrap()[..]).unwrap();
7619                                 let sighash = unsigned_tx.get_sighash_all(&redeemscript, chan.channel_value_satoshis);
7620                                 log_trace!(logger, "unsigned_tx = {}", hex::encode(serialize(&unsigned_tx.transaction)));
7621                                 assert!(secp_ctx.verify_ecdsa(&sighash, &counterparty_signature, chan.counterparty_funding_pubkey()).is_ok(), "verify counterparty commitment sig");
7622
7623                                 let mut per_htlc: Vec<(HTLCOutputInCommitment, Option<Signature>)> = Vec::new();
7624                                 per_htlc.clear(); // Don't warn about excess mut for no-HTLC calls
7625                                 let mut counterparty_htlc_sigs = Vec::new();
7626                                 counterparty_htlc_sigs.clear(); // Don't warn about excess mut for no-HTLC calls
7627                                 $({
7628                                         let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
7629                                         per_htlc.push((htlcs[$htlc_idx].clone(), Some(remote_signature)));
7630                                         counterparty_htlc_sigs.push(remote_signature);
7631                                 })*
7632                                 assert_eq!(htlcs.len(), per_htlc.len());
7633
7634                                 let holder_commitment_tx = HolderCommitmentTransaction::new(
7635                                         commitment_tx.clone(),
7636                                         counterparty_signature,
7637                                         counterparty_htlc_sigs,
7638                                         &chan.holder_signer.pubkeys().funding_pubkey,
7639                                         chan.counterparty_funding_pubkey()
7640                                 );
7641                                 let (holder_sig, htlc_sigs) = signer.sign_holder_commitment_and_htlcs(&holder_commitment_tx, &secp_ctx).unwrap();
7642                                 assert_eq!(Signature::from_der(&hex::decode($sig_hex).unwrap()[..]).unwrap(), holder_sig, "holder_sig");
7643
7644                                 let funding_redeemscript = chan.get_funding_redeemscript();
7645                                 let tx = holder_commitment_tx.add_holder_sig(&funding_redeemscript, holder_sig);
7646                                 assert_eq!(serialize(&tx)[..], hex::decode($tx_hex).unwrap()[..], "tx");
7647
7648                                 // ((htlc, counterparty_sig), (index, holder_sig))
7649                                 let mut htlc_sig_iter = holder_commitment_tx.htlcs().iter().zip(&holder_commitment_tx.counterparty_htlc_sigs).zip(htlc_sigs.iter().enumerate());
7650
7651                                 $({
7652                                         log_trace!(logger, "verifying htlc {}", $htlc_idx);
7653                                         let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
7654
7655                                         let ref htlc = htlcs[$htlc_idx];
7656                                         let htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, chan.feerate_per_kw,
7657                                                 chan.get_counterparty_selected_contest_delay().unwrap(),
7658                                                 &htlc, $opt_anchors, false, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
7659                                         let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, $opt_anchors, &keys);
7660                                         let htlc_sighashtype = if $opt_anchors { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
7661                                         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();
7662                                         assert!(secp_ctx.verify_ecdsa(&htlc_sighash, &remote_signature, &keys.countersignatory_htlc_key).is_ok(), "verify counterparty htlc sig");
7663
7664                                         let mut preimage: Option<PaymentPreimage> = None;
7665                                         if !htlc.offered {
7666                                                 for i in 0..5 {
7667                                                         let out = PaymentHash(Sha256::hash(&[i; 32]).into_inner());
7668                                                         if out == htlc.payment_hash {
7669                                                                 preimage = Some(PaymentPreimage([i; 32]));
7670                                                         }
7671                                                 }
7672
7673                                                 assert!(preimage.is_some());
7674                                         }
7675
7676                                         let htlc_sig = htlc_sig_iter.next().unwrap();
7677                                         let num_anchors = if $opt_anchors { 2 } else { 0 };
7678                                         assert_eq!((htlc_sig.0).0.transaction_output_index, Some($htlc_idx + num_anchors), "output index");
7679
7680                                         let signature = Signature::from_der(&hex::decode($htlc_sig_hex).unwrap()[..]).unwrap();
7681                                         assert_eq!(signature, *(htlc_sig.1).1, "htlc sig");
7682                                         let index = (htlc_sig.1).0;
7683                                         let channel_parameters = chan.channel_transaction_parameters.as_holder_broadcastable();
7684                                         let trusted_tx = holder_commitment_tx.trust();
7685                                         log_trace!(logger, "htlc_tx = {}", hex::encode(serialize(&trusted_tx.get_signed_htlc_tx(&channel_parameters, index, &(htlc_sig.0).1, (htlc_sig.1).1, &preimage))));
7686                                         assert_eq!(serialize(&trusted_tx.get_signed_htlc_tx(&channel_parameters, index, &(htlc_sig.0).1, (htlc_sig.1).1, &preimage))[..],
7687                                                         hex::decode($htlc_tx_hex).unwrap()[..], "htlc tx");
7688                                 })*
7689                                 assert!(htlc_sig_iter.next().is_none());
7690                         } }
7691                 }
7692
7693                 // anchors: simple commitment tx with no HTLCs and single anchor
7694                 test_commitment_with_anchors!("30440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a8658",
7695                                                  "3044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778",
7696                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
7697
7698                 // simple commitment tx with no HTLCs
7699                 chan.value_to_self_msat = 7000000000;
7700
7701                 test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
7702                                                  "30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
7703                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48454a56a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004730440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae05564714201483045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
7704
7705                 // anchors: simple commitment tx with no HTLCs
7706                 test_commitment_with_anchors!("3045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f3",
7707                                                  "30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
7708                                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
7709
7710                 chan.pending_inbound_htlcs.push({
7711                         let mut out = InboundHTLCOutput{
7712                                 htlc_id: 0,
7713                                 amount_msat: 1000000,
7714                                 cltv_expiry: 500,
7715                                 payment_hash: PaymentHash([0; 32]),
7716                                 state: InboundHTLCState::Committed,
7717                         };
7718                         out.payment_hash.0 = Sha256::hash(&hex::decode("0000000000000000000000000000000000000000000000000000000000000000").unwrap()).into_inner();
7719                         out
7720                 });
7721                 chan.pending_inbound_htlcs.push({
7722                         let mut out = InboundHTLCOutput{
7723                                 htlc_id: 1,
7724                                 amount_msat: 2000000,
7725                                 cltv_expiry: 501,
7726                                 payment_hash: PaymentHash([0; 32]),
7727                                 state: InboundHTLCState::Committed,
7728                         };
7729                         out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
7730                         out
7731                 });
7732                 chan.pending_outbound_htlcs.push({
7733                         let mut out = OutboundHTLCOutput{
7734                                 htlc_id: 2,
7735                                 amount_msat: 2000000,
7736                                 cltv_expiry: 502,
7737                                 payment_hash: PaymentHash([0; 32]),
7738                                 state: OutboundHTLCState::Committed,
7739                                 source: HTLCSource::dummy(),
7740                         };
7741                         out.payment_hash.0 = Sha256::hash(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()).into_inner();
7742                         out
7743                 });
7744                 chan.pending_outbound_htlcs.push({
7745                         let mut out = OutboundHTLCOutput{
7746                                 htlc_id: 3,
7747                                 amount_msat: 3000000,
7748                                 cltv_expiry: 503,
7749                                 payment_hash: PaymentHash([0; 32]),
7750                                 state: OutboundHTLCState::Committed,
7751                                 source: HTLCSource::dummy(),
7752                         };
7753                         out.payment_hash.0 = Sha256::hash(&hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()).into_inner();
7754                         out
7755                 });
7756                 chan.pending_inbound_htlcs.push({
7757                         let mut out = InboundHTLCOutput{
7758                                 htlc_id: 4,
7759                                 amount_msat: 4000000,
7760                                 cltv_expiry: 504,
7761                                 payment_hash: PaymentHash([0; 32]),
7762                                 state: InboundHTLCState::Committed,
7763                         };
7764                         out.payment_hash.0 = Sha256::hash(&hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()).into_inner();
7765                         out
7766                 });
7767
7768                 // commitment tx with all five HTLCs untrimmed (minimum feerate)
7769                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7770                 chan.feerate_per_kw = 0;
7771
7772                 test_commitment!("3044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e5",
7773                                  "304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea",
7774                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e0a06a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea01473044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7775
7776                                   { 0,
7777                                   "3045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b",
7778                                   "30440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce",
7779                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b00000000000000000001e8030000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b014730440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
7780
7781                                   { 1,
7782                                   "30440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f896004",
7783                                   "3045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f",
7784                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b01000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f89600401483045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7785
7786                                   { 2,
7787                                   "30440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d43352",
7788                                   "3045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa",
7789                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b02000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d4335201483045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
7790
7791                                   { 3,
7792                                   "304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c1363",
7793                                   "304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac7487",
7794                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b03000000000000000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c13630147304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac748701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7795
7796                                   { 4,
7797                                   "3044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b87",
7798                                   "3045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95",
7799                                   "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b04000000000000000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b8701483045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7800                 } );
7801
7802                 // commitment tx with seven outputs untrimmed (maximum feerate)
7803                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7804                 chan.feerate_per_kw = 647;
7805
7806                 test_commitment!("3045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee",
7807                                  "30450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb7",
7808                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e09c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb701483045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7809
7810                                   { 0,
7811                                   "30450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f",
7812                                   "30440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b",
7813                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f014730440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
7814
7815                                   { 1,
7816                                   "304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c",
7817                                   "30450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f",
7818                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0100000000000000000124060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c014830450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7819
7820                                   { 2,
7821                                   "30440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c8",
7822                                   "3045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673",
7823                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe020000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c801483045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
7824
7825                                   { 3,
7826                                   "304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c64",
7827                                   "3045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee",
7828                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe030000000000000000010c0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c6401483045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7829
7830                                   { 4,
7831                                   "30450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca",
7832                                   "3044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9",
7833                                   "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe04000000000000000001da0d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca01473044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7834                 } );
7835
7836                 // commitment tx with six outputs untrimmed (minimum feerate)
7837                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7838                 chan.feerate_per_kw = 648;
7839
7840                 test_commitment!("304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e5",
7841                                  "3045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e9",
7842                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4844e9d6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e90147304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7843
7844                                   { 0,
7845                                   "3045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e0",
7846                                   "304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec6",
7847                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10000000000000000000123060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e00148304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7848
7849                                   { 1,
7850                                   "304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d384124",
7851                                   "3044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae",
7852                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10100000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d38412401473044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
7853
7854                                   { 2,
7855                                   "304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc625532989",
7856                                   "3045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e2260796",
7857                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf1020000000000000000010b0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc62553298901483045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e226079601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7858
7859                                   { 3,
7860                                   "3044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be",
7861                                   "3045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6",
7862                                   "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf103000000000000000001d90d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be01483045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7863                 } );
7864
7865                 // anchors: commitment tx with six outputs untrimmed (minimum dust limit)
7866                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7867                 chan.feerate_per_kw = 645;
7868                 chan.holder_dust_limit_satoshis = 1001;
7869
7870                 test_commitment_with_anchors!("3044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc312",
7871                                  "3045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d0051",
7872                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80084a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d0070000000000002200203e68115ae0b15b8de75b6c6bc9af5ac9f01391544e0870dae443a1e8fe7837ead007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5eb80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994abc996a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d005101473044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc31201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7873
7874                                   { 0,
7875                                   "3045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc282",
7876                                   "3045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef09",
7877                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320002000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc28283483045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef0901008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6851b27568f6010000" },
7878
7879                                   { 1,
7880                                   "3045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e",
7881                                   "3045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac",
7882                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320003000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e83483045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
7883
7884                                   { 2,
7885                                   "3044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c1",
7886                                   "304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e",
7887                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320004000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c18347304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
7888
7889                                   { 3,
7890                                   "3044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc615",
7891                                   "3045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226",
7892                                   "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320005000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc61583483045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
7893                 } );
7894
7895                 // commitment tx with six outputs untrimmed (maximum feerate)
7896                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7897                 chan.feerate_per_kw = 2069;
7898                 chan.holder_dust_limit_satoshis = 546;
7899
7900                 test_commitment!("304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc",
7901                                  "3045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e33",
7902                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48477956a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e330148304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7903
7904                                   { 0,
7905                                   "3045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f699",
7906                                   "3045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d",
7907                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0000000000000000000175020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f69901483045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7908
7909                                   { 1,
7910                                   "3045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df",
7911                                   "3045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61",
7912                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0100000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df01483045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
7913
7914                                   { 2,
7915                                   "3045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e0",
7916                                   "3044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c18",
7917                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d020000000000000000015d060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e001473044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c1801008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7918
7919                                   { 3,
7920                                   "304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df",
7921                                   "3045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33",
7922                                   "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d03000000000000000001f2090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df01483045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7923                 } );
7924
7925                 // commitment tx with five outputs untrimmed (minimum feerate)
7926                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7927                 chan.feerate_per_kw = 2070;
7928
7929                 test_commitment!("304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c",
7930                                  "3044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c1",
7931                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484da966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c10147304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7932
7933                                   { 0,
7934                                   "304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b",
7935                                   "30440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e5",
7936                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff0000000000000000000174020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b014730440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e501008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7937
7938                                   { 1,
7939                                   "3045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546",
7940                                   "30450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c6",
7941                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff010000000000000000015c060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546014830450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7942
7943                                   { 2,
7944                                   "3045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504",
7945                                   "30440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502",
7946                                   "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff02000000000000000001f1090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504014730440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7947                 } );
7948
7949                 // commitment tx with five outputs untrimmed (maximum feerate)
7950                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7951                 chan.feerate_per_kw = 2194;
7952
7953                 test_commitment!("304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb3",
7954                                  "3044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d398",
7955                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48440966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d3980147304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7956
7957                                   { 0,
7958                                   "3045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de8450",
7959                                   "304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e0154301",
7960                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de84500148304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e015430101008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
7961
7962                                   { 1,
7963                                   "3044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a0",
7964                                   "3045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b77",
7965                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd010000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a001483045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b7701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7966
7967                                   { 2,
7968                                   "3045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b",
7969                                   "30450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3",
7970                                   "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd020000000000000000019a090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b014830450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7971                 } );
7972
7973                 // commitment tx with four outputs untrimmed (minimum feerate)
7974                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7975                 chan.feerate_per_kw = 2195;
7976
7977                 test_commitment!("304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce403",
7978                                  "3044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d1767",
7979                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484b8976a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d17670147304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce40301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
7980
7981                                   { 0,
7982                                   "3045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e",
7983                                   "3045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d76",
7984                                   "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900000000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e01483045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d7601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
7985
7986                                   { 1,
7987                                   "3045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a",
7988                                   "3044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82",
7989                                   "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900100000000000000000199090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a01473044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
7990                 } );
7991
7992                 // anchors: commitment tx with four outputs untrimmed (minimum dust limit)
7993                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
7994                 chan.feerate_per_kw = 2185;
7995                 chan.holder_dust_limit_satoshis = 2001;
7996
7997                 test_commitment_with_anchors!("3044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c0",
7998                                  "3045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd5",
7999                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80064a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994b80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ac5916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd501473044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8000
8001                                   { 0,
8002                                   "304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb",
8003                                   "30440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f",
8004                                   "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc02000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb834730440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
8005
8006                                   { 1,
8007                                   "3045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd7271",
8008                                   "3045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688",
8009                                   "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc03000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd727183483045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
8010                 } );
8011
8012                 // commitment tx with four outputs untrimmed (maximum feerate)
8013                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8014                 chan.feerate_per_kw = 3702;
8015                 chan.holder_dust_limit_satoshis = 546;
8016
8017                 test_commitment!("304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee40169",
8018                                  "3045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf75",
8019                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4846f916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf750148304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee4016901475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8020
8021                                   { 0,
8022                                   "304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb89",
8023                                   "304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f",
8024                                   "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb890147304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8025
8026                                   { 1,
8027                                   "3044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb5817",
8028                                   "304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc",
8029                                   "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0100000000000000000176050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb58170147304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8030                 } );
8031
8032                 // commitment tx with three outputs untrimmed (minimum feerate)
8033                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8034                 chan.feerate_per_kw = 3703;
8035
8036                 test_commitment!("3045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e",
8037                                  "304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e1",
8038                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484eb936a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e101483045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8039
8040                                   { 0,
8041                                   "3045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a",
8042                                   "3045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05",
8043                                   "0200000000010120060e4a29579d429f0f27c17ee5f1ee282f20d706d6f90b63d35946d8f3029a0000000000000000000175050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a01483045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8044                 } );
8045
8046                 // anchors: commitment tx with three outputs untrimmed (minimum dust limit)
8047                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8048                 chan.feerate_per_kw = 3687;
8049                 chan.holder_dust_limit_satoshis = 3001;
8050
8051                 test_commitment_with_anchors!("3045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c228377",
8052                                  "3045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d",
8053                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80054a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aa28b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d01483045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c22837701475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8054
8055                                   { 0,
8056                                   "3044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c",
8057                                   "3045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de",
8058                                   "02000000000101542562b326c08e3a076d9cfca2be175041366591da334d8d513ff1686fd95a6002000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c83483045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
8059                 } );
8060
8061                 // commitment tx with three outputs untrimmed (maximum feerate)
8062                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8063                 chan.feerate_per_kw = 4914;
8064                 chan.holder_dust_limit_satoshis = 546;
8065
8066                 test_commitment!("3045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c95244",
8067                                  "3045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c19",
8068                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484ae8f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c1901483045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c9524401475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8069
8070                                   { 0,
8071                                   "3045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374",
8072                                   "30440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10",
8073                                   "02000000000101a9172908eace869cc35128c31fc2ab502f72e4dff31aab23e0244c4b04b11ab00000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374014730440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8074                 } );
8075
8076                 // commitment tx with two outputs untrimmed (minimum feerate)
8077                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8078                 chan.feerate_per_kw = 4915;
8079                 chan.holder_dust_limit_satoshis = 546;
8080
8081                 test_commitment!("304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a720",
8082                                  "30450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf5",
8083                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484fa926a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf50147304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a72001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8084
8085                 // anchors: commitment tx with two outputs untrimmed (minimum dust limit)
8086                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8087                 chan.feerate_per_kw = 4894;
8088                 chan.holder_dust_limit_satoshis = 4001;
8089
8090                 test_commitment_with_anchors!("3045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b95",
8091                                  "30450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd",
8092                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ad0886a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd01483045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b9501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8093
8094                 // commitment tx with two outputs untrimmed (maximum feerate)
8095                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8096                 chan.feerate_per_kw = 9651180;
8097                 chan.holder_dust_limit_satoshis = 546;
8098
8099                 test_commitment!("304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd3",
8100                                  "3045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de",
8101                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b800222020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80ec0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4840400483045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de0147304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8102
8103                 // commitment tx with one output untrimmed (minimum feerate)
8104                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8105                 chan.feerate_per_kw = 9651181;
8106
8107                 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
8108                                  "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
8109                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8110
8111                 // anchors: commitment tx with one output untrimmed (minimum dust limit)
8112                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8113                 chan.feerate_per_kw = 6216010;
8114                 chan.holder_dust_limit_satoshis = 4001;
8115
8116                 test_commitment_with_anchors!("30450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf",
8117                                  "30450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1",
8118                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a04004830450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1014830450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8119
8120                 // commitment tx with fee greater than funder amount
8121                 chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8122                 chan.feerate_per_kw = 9651936;
8123                 chan.holder_dust_limit_satoshis = 546;
8124
8125                 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
8126                                  "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
8127                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8128
8129                 // commitment tx with 3 htlc outputs, 2 offered having the same amount and preimage
8130                 chan.value_to_self_msat = 7_000_000_000 - 2_000_000;
8131                 chan.feerate_per_kw = 253;
8132                 chan.pending_inbound_htlcs.clear();
8133                 chan.pending_inbound_htlcs.push({
8134                         let mut out = InboundHTLCOutput{
8135                                 htlc_id: 1,
8136                                 amount_msat: 2000000,
8137                                 cltv_expiry: 501,
8138                                 payment_hash: PaymentHash([0; 32]),
8139                                 state: InboundHTLCState::Committed,
8140                         };
8141                         out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
8142                         out
8143                 });
8144                 chan.pending_outbound_htlcs.clear();
8145                 chan.pending_outbound_htlcs.push({
8146                         let mut out = OutboundHTLCOutput{
8147                                 htlc_id: 6,
8148                                 amount_msat: 5000001,
8149                                 cltv_expiry: 506,
8150                                 payment_hash: PaymentHash([0; 32]),
8151                                 state: OutboundHTLCState::Committed,
8152                                 source: HTLCSource::dummy(),
8153                         };
8154                         out.payment_hash.0 = Sha256::hash(&hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).into_inner();
8155                         out
8156                 });
8157                 chan.pending_outbound_htlcs.push({
8158                         let mut out = OutboundHTLCOutput{
8159                                 htlc_id: 5,
8160                                 amount_msat: 5000000,
8161                                 cltv_expiry: 505,
8162                                 payment_hash: PaymentHash([0; 32]),
8163                                 state: OutboundHTLCState::Committed,
8164                                 source: HTLCSource::dummy(),
8165                         };
8166                         out.payment_hash.0 = Sha256::hash(&hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).into_inner();
8167                         out
8168                 });
8169
8170                 test_commitment!("304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c8",
8171                                  "304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c",
8172                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2d8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121b8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121bc0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484a69f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c0147304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8173
8174                                   { 0,
8175                                   "3045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce5",
8176                                   "3044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b",
8177                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec000000000000000000011f070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce501473044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8178                                   { 1,
8179                                   "3045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a",
8180                                   "3045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d",
8181                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec01000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a01483045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868f9010000" },
8182                                   { 2,
8183                                   "30440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc",
8184                                   "304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb",
8185                                   "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec02000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc0147304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868fa010000" }
8186                 } );
8187
8188                 test_commitment_with_anchors!("3044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c725",
8189                                  "3045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b76",
8190                                  "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80074a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5e881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aad9c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b7601473044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c72501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8191
8192                                   { 0,
8193                                   "30440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c2",
8194                                   "304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424",
8195                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c402000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c28347304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
8196                                   { 1,
8197                                   "304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c",
8198                                   "304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b",
8199                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40300000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c8347304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568f9010000" },
8200                                   { 2,
8201                                   "3045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a1",
8202                                   "3045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b",
8203                                   "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40400000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a183483045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568fa010000" }
8204                 } );
8205         }
8206
8207         #[test]
8208         fn test_per_commitment_secret_gen() {
8209                 // Test vectors from BOLT 3 Appendix D:
8210
8211                 let mut seed = [0; 32];
8212                 seed[0..32].clone_from_slice(&hex::decode("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
8213                 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
8214                            hex::decode("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]);
8215
8216                 seed[0..32].clone_from_slice(&hex::decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap());
8217                 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
8218                            hex::decode("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]);
8219
8220                 assert_eq!(chan_utils::build_commitment_secret(&seed, 0xaaaaaaaaaaa),
8221                            hex::decode("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]);
8222
8223                 assert_eq!(chan_utils::build_commitment_secret(&seed, 0x555555555555),
8224                            hex::decode("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]);
8225
8226                 seed[0..32].clone_from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap());
8227                 assert_eq!(chan_utils::build_commitment_secret(&seed, 1),
8228                            hex::decode("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]);
8229         }
8230
8231         #[test]
8232         fn test_key_derivation() {
8233                 // Test vectors from BOLT 3 Appendix E:
8234                 let secp_ctx = Secp256k1::new();
8235
8236                 let base_secret = SecretKey::from_slice(&hex::decode("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap();
8237                 let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
8238
8239                 let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret);
8240                 assert_eq!(base_point.serialize()[..], hex::decode("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]);
8241
8242                 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
8243                 assert_eq!(per_commitment_point.serialize()[..], hex::decode("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]);
8244
8245                 assert_eq!(chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &base_point).serialize()[..],
8246                                 hex::decode("0235f2dbfaa89b57ec7b055afe29849ef7ddfeb1cefdb9ebdc43f5494984db29e5").unwrap()[..]);
8247
8248                 assert_eq!(chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &base_secret),
8249                                 SecretKey::from_slice(&hex::decode("cbced912d3b21bf196a766651e436aff192362621ce317704ea2f75d87e7be0f").unwrap()[..]).unwrap());
8250
8251                 assert_eq!(chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &base_point).serialize()[..],
8252                                 hex::decode("02916e326636d19c33f13e8c0c3a03dd157f332f3e99c317c141dd865eb01f8ff0").unwrap()[..]);
8253
8254                 assert_eq!(chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_secret, &base_secret),
8255                                 SecretKey::from_slice(&hex::decode("d09ffff62ddb2297ab000cc85bcb4283fdeb6aa052affbc9dddcf33b61078110").unwrap()[..]).unwrap());
8256         }
8257
8258         #[test]
8259         fn test_zero_conf_channel_type_support() {
8260                 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8261                 let secp_ctx = Secp256k1::new();
8262                 let seed = [42; 32];
8263                 let network = Network::Testnet;
8264                 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8265                 let logger = test_utils::TestLogger::new();
8266
8267                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8268                 let config = UserConfig::default();
8269                 let node_a_chan = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider,
8270                         node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
8271
8272                 let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
8273                 channel_type_features.set_zero_conf_required();
8274
8275                 let mut open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
8276                 open_channel_msg.channel_type = Some(channel_type_features);
8277                 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
8278                 let res = Channel::<EnforcingSigner>::new_from_req(&feeest, &&keys_provider, &&keys_provider,
8279                         node_b_node_id, &channelmanager::provided_channel_type_features(&config),
8280                         &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, 42);
8281                 assert!(res.is_ok());
8282         }
8283
8284         #[cfg(anchors)]
8285         #[test]
8286         fn test_supports_anchors_zero_htlc_tx_fee() {
8287                 // Tests that if both sides support and negotiate `anchors_zero_fee_htlc_tx`, it is the
8288                 // resulting `channel_type`.
8289                 let secp_ctx = Secp256k1::new();
8290                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8291                 let network = Network::Testnet;
8292                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8293                 let logger = test_utils::TestLogger::new();
8294
8295                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8296                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8297
8298                 let mut config = UserConfig::default();
8299                 config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
8300
8301                 // It is not enough for just the initiator to signal `option_anchors_zero_fee_htlc_tx`, both
8302                 // need to signal it.
8303                 let channel_a = Channel::<EnforcingSigner>::new_outbound(
8304                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8305                         &channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42,
8306                         &config, 0, 42
8307                 ).unwrap();
8308                 assert!(!channel_a.channel_type.supports_anchors_zero_fee_htlc_tx());
8309
8310                 let mut expected_channel_type = ChannelTypeFeatures::empty();
8311                 expected_channel_type.set_static_remote_key_required();
8312                 expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
8313
8314                 let channel_a = Channel::<EnforcingSigner>::new_outbound(
8315                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8316                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8317                 ).unwrap();
8318
8319                 let open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8320                 let channel_b = Channel::<EnforcingSigner>::new_from_req(
8321                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8322                         &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
8323                         &open_channel_msg, 7, &config, 0, &&logger, 42
8324                 ).unwrap();
8325
8326                 assert_eq!(channel_a.channel_type, expected_channel_type);
8327                 assert_eq!(channel_b.channel_type, expected_channel_type);
8328         }
8329
8330         #[cfg(anchors)]
8331         #[test]
8332         fn test_rejects_implicit_simple_anchors() {
8333                 // Tests that if `option_anchors` is being negotiated implicitly through the intersection of
8334                 // each side's `InitFeatures`, it is rejected.
8335                 let secp_ctx = Secp256k1::new();
8336                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8337                 let network = Network::Testnet;
8338                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8339                 let logger = test_utils::TestLogger::new();
8340
8341                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8342                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8343
8344                 let config = UserConfig::default();
8345
8346                 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
8347                 let static_remote_key_required: u64 = 1 << 12;
8348                 let simple_anchors_required: u64 = 1 << 20;
8349                 let raw_init_features = static_remote_key_required | simple_anchors_required;
8350                 let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
8351
8352                 let channel_a = Channel::<EnforcingSigner>::new_outbound(
8353                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8354                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8355                 ).unwrap();
8356
8357                 // Set `channel_type` to `None` to force the implicit feature negotiation.
8358                 let mut open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8359                 open_channel_msg.channel_type = None;
8360
8361                 // Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
8362                 // `static_remote_key`, it will fail the channel.
8363                 let channel_b = Channel::<EnforcingSigner>::new_from_req(
8364                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8365                         &channelmanager::provided_channel_type_features(&config), &init_features_with_simple_anchors,
8366                         &open_channel_msg, 7, &config, 0, &&logger, 42
8367                 );
8368                 assert!(channel_b.is_err());
8369         }
8370
8371         #[cfg(anchors)]
8372         #[test]
8373         fn test_rejects_simple_anchors_channel_type() {
8374                 // Tests that if `option_anchors` is being negotiated through the `channel_type` feature,
8375                 // it is rejected.
8376                 let secp_ctx = Secp256k1::new();
8377                 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8378                 let network = Network::Testnet;
8379                 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8380                 let logger = test_utils::TestLogger::new();
8381
8382                 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8383                 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8384
8385                 let config = UserConfig::default();
8386
8387                 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
8388                 let static_remote_key_required: u64 = 1 << 12;
8389                 let simple_anchors_required: u64 = 1 << 20;
8390                 let simple_anchors_raw_features = static_remote_key_required | simple_anchors_required;
8391                 let simple_anchors_init = InitFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
8392                 let simple_anchors_channel_type = ChannelTypeFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
8393                 assert!(simple_anchors_init.requires_unknown_bits());
8394                 assert!(simple_anchors_channel_type.requires_unknown_bits());
8395
8396                 // First, we'll try to open a channel between A and B where A requests a channel type for
8397                 // the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
8398                 // B as it's not supported by LDK.
8399                 let channel_a = Channel::<EnforcingSigner>::new_outbound(
8400                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8401                         &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8402                 ).unwrap();
8403
8404                 let mut open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8405                 open_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
8406
8407                 let res = Channel::<EnforcingSigner>::new_from_req(
8408                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8409                         &channelmanager::provided_channel_type_features(&config), &simple_anchors_init,
8410                         &open_channel_msg, 7, &config, 0, &&logger, 42
8411                 );
8412                 assert!(res.is_err());
8413
8414                 // Then, we'll try to open another channel where A requests a channel type for
8415                 // `anchors_zero_fee_htlc_tx`. B is malicious and tries to downgrade the channel type to the
8416                 // original `option_anchors` feature, which should be rejected by A as it's not supported by
8417                 // LDK.
8418                 let mut channel_a = Channel::<EnforcingSigner>::new_outbound(
8419                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &simple_anchors_init,
8420                         10000000, 100000, 42, &config, 0, 42
8421                 ).unwrap();
8422
8423                 let open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8424
8425                 let channel_b = Channel::<EnforcingSigner>::new_from_req(
8426                         &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8427                         &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
8428                         &open_channel_msg, 7, &config, 0, &&logger, 42
8429                 ).unwrap();
8430
8431                 let mut accept_channel_msg = channel_b.get_accept_channel_message();
8432                 accept_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
8433
8434                 let res = channel_a.accept_channel(
8435                         &accept_channel_msg, &config.channel_handshake_limits, &simple_anchors_init
8436                 );
8437                 assert!(res.is_err());
8438         }
8439 }