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