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