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