1 // This file is Copyright its original authors, visible in version control
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
10 use bitcoin::blockdata::script::{Script,Builder};
11 use bitcoin::blockdata::transaction::{Transaction, EcdsaSighashType};
12 use bitcoin::util::sighash;
13 use bitcoin::consensus::encode;
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};
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;
25 use crate::ln::{PaymentPreimage, PaymentHash};
26 use crate::ln::features::{ChannelTypeFeatures, InitFeatures};
28 use crate::ln::msgs::DecodeError;
29 use crate::ln::script::{self, ShutdownScript};
30 use crate::ln::channelmanager::{self, CounterpartyForwardingInfo, PendingHTLCStatus, HTLCSource, SentHTLCId, HTLCFailureMsg, PendingHTLCInfo, RAACommitmentOrder, BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA, MAX_LOCAL_BREAKDOWN_TIMEOUT};
31 use crate::ln::chan_utils::{CounterpartyCommitmentSecrets, TxCreationKeys, HTLCOutputInCommitment, htlc_success_tx_weight, htlc_timeout_tx_weight, make_funding_redeemscript, ChannelPublicKeys, CommitmentTransaction, HolderCommitmentTransaction, ChannelTransactionParameters, CounterpartyChannelTransactionParameters, MAX_HTLCS, get_commitment_transaction_number_obscure_factor, ClosingTransaction};
32 use crate::ln::chan_utils;
33 use crate::ln::onion_utils::HTLCFailReason;
34 use crate::chain::BestBlock;
35 use crate::chain::chaininterface::{FeeEstimator, ConfirmationTarget, LowerBoundedFeeEstimator};
36 use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, LATENCY_GRACE_PERIOD_BLOCKS, CLOSED_CHANNEL_UPDATE_ID};
37 use crate::chain::transaction::{OutPoint, TransactionData};
38 use crate::sign::{WriteableEcdsaChannelSigner, EntropySource, ChannelSigner, SignerProvider, NodeSigner, Recipient};
39 use crate::events::ClosureReason;
40 use crate::routing::gossip::NodeId;
41 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer, VecWriter};
42 use crate::util::logger::Logger;
43 use crate::util::errors::APIError;
44 use crate::util::config::{UserConfig, ChannelConfig, LegacyChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits, MaxDustHTLCExposure};
45 use crate::util::scid_utils::scid_from_parts;
48 use crate::prelude::*;
49 use core::{cmp,mem,fmt};
51 #[cfg(any(test, fuzzing, debug_assertions))]
52 use crate::sync::Mutex;
53 use bitcoin::hashes::hex::ToHex;
56 pub struct ChannelValueStat {
57 pub value_to_self_msat: u64,
58 pub channel_value_msat: u64,
59 pub channel_reserve_msat: u64,
60 pub pending_outbound_htlcs_amount_msat: u64,
61 pub pending_inbound_htlcs_amount_msat: u64,
62 pub holding_cell_outbound_amount_msat: u64,
63 pub counterparty_max_htlc_value_in_flight_msat: u64, // outgoing
64 pub counterparty_dust_limit_msat: u64,
67 pub struct AvailableBalances {
68 /// The amount that would go to us if we close the channel, ignoring any on-chain fees.
69 pub balance_msat: u64,
70 /// Total amount available for our counterparty to send to us.
71 pub inbound_capacity_msat: u64,
72 /// Total amount available for us to send to our counterparty.
73 pub outbound_capacity_msat: u64,
74 /// The maximum value we can assign to the next outbound HTLC
75 pub next_outbound_htlc_limit_msat: u64,
76 /// The minimum value we can assign to the next outbound HTLC
77 pub next_outbound_htlc_minimum_msat: u64,
80 #[derive(Debug, Clone, Copy, PartialEq)]
82 // Inbound states mirroring InboundHTLCState
84 AwaitingRemoteRevokeToAnnounce,
85 // Note that we do not have a AwaitingAnnouncedRemoteRevoke variant here as it is universally
86 // handled the same as `Committed`, with the only exception in `InboundHTLCState` being the
87 // distinction of when we allow ourselves to forward the HTLC. Because we aren't "forwarding"
88 // the fee update anywhere, we can simply consider the fee update `Committed` immediately
89 // instead of setting it to AwaitingAnnouncedRemoteRevoke.
91 // Outbound state can only be `LocalAnnounced` or `Committed`
95 enum InboundHTLCRemovalReason {
96 FailRelay(msgs::OnionErrorPacket),
97 FailMalformed(([u8; 32], u16)),
98 Fulfill(PaymentPreimage),
101 enum InboundHTLCState {
102 /// Offered by remote, to be included in next local commitment tx. I.e., the remote sent an
103 /// update_add_htlc message for this HTLC.
104 RemoteAnnounced(PendingHTLCStatus),
105 /// Included in a received commitment_signed message (implying we've
106 /// revoke_and_ack'd it), but the remote hasn't yet revoked their previous
107 /// state (see the example below). We have not yet included this HTLC in a
108 /// commitment_signed message because we are waiting on the remote's
109 /// aforementioned state revocation. One reason this missing remote RAA
110 /// (revoke_and_ack) blocks us from constructing a commitment_signed message
111 /// is because every time we create a new "state", i.e. every time we sign a
112 /// new commitment tx (see [BOLT #2]), we need a new per_commitment_point,
113 /// which are provided one-at-a-time in each RAA. E.g., the last RAA they
114 /// sent provided the per_commitment_point for our current commitment tx.
115 /// The other reason we should not send a commitment_signed without their RAA
116 /// is because their RAA serves to ACK our previous commitment_signed.
118 /// Here's an example of how an HTLC could come to be in this state:
119 /// remote --> update_add_htlc(prev_htlc) --> local
120 /// remote --> commitment_signed(prev_htlc) --> local
121 /// remote <-- revoke_and_ack <-- local
122 /// remote <-- commitment_signed(prev_htlc) <-- local
123 /// [note that here, the remote does not respond with a RAA]
124 /// remote --> update_add_htlc(this_htlc) --> local
125 /// remote --> commitment_signed(prev_htlc, this_htlc) --> local
126 /// Now `this_htlc` will be assigned this state. It's unable to be officially
127 /// accepted, i.e. included in a commitment_signed, because we're missing the
128 /// RAA that provides our next per_commitment_point. The per_commitment_point
129 /// is used to derive commitment keys, which are used to construct the
130 /// signatures in a commitment_signed message.
131 /// Implies AwaitingRemoteRevoke.
133 /// [BOLT #2]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
134 AwaitingRemoteRevokeToAnnounce(PendingHTLCStatus),
135 /// Included in a received commitment_signed message (implying we've revoke_and_ack'd it).
136 /// We have also included this HTLC in our latest commitment_signed and are now just waiting
137 /// on the remote's revoke_and_ack to make this HTLC an irrevocable part of the state of the
138 /// channel (before it can then get forwarded and/or removed).
139 /// Implies AwaitingRemoteRevoke.
140 AwaitingAnnouncedRemoteRevoke(PendingHTLCStatus),
142 /// Removed by us and a new commitment_signed was sent (if we were AwaitingRemoteRevoke when we
143 /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
145 /// Note that we have to keep an eye on the HTLC until we've received a broadcastable
146 /// commitment transaction without it as otherwise we'll have to force-close the channel to
147 /// claim it before the timeout (obviously doesn't apply to revoked HTLCs that we can't claim
148 /// anyway). That said, ChannelMonitor does this for us (see
149 /// ChannelMonitor::should_broadcast_holder_commitment_txn) so we actually remove the HTLC from
150 /// our own local state before then, once we're sure that the next commitment_signed and
151 /// ChannelMonitor::provide_latest_local_commitment_tx will not include this HTLC.
152 LocalRemoved(InboundHTLCRemovalReason),
155 struct InboundHTLCOutput {
159 payment_hash: PaymentHash,
160 state: InboundHTLCState,
163 enum OutboundHTLCState {
164 /// Added by us and included in a commitment_signed (if we were AwaitingRemoteRevoke when we
165 /// created it we would have put it in the holding cell instead). When they next revoke_and_ack
166 /// we will promote to Committed (note that they may not accept it until the next time we
167 /// revoke, but we don't really care about that:
168 /// * they've revoked, so worst case we can announce an old state and get our (option on)
169 /// money back (though we won't), and,
170 /// * we'll send them a revoke when they send a commitment_signed, and since only they're
171 /// allowed to remove it, the "can only be removed once committed on both sides" requirement
172 /// doesn't matter to us and it's up to them to enforce it, worst-case they jump ahead but
173 /// we'll never get out of sync).
174 /// Note that we Box the OnionPacket as it's rather large and we don't want to blow up
175 /// OutboundHTLCOutput's size just for a temporary bit
176 LocalAnnounced(Box<msgs::OnionPacket>),
178 /// Remote removed this (outbound) HTLC. We're waiting on their commitment_signed to finalize
179 /// the change (though they'll need to revoke before we fail the payment).
180 RemoteRemoved(OutboundHTLCOutcome),
181 /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
182 /// the remote side hasn't yet revoked their previous state, which we need them to do before we
183 /// can do any backwards failing. Implies AwaitingRemoteRevoke.
184 /// We also have not yet removed this HTLC in a commitment_signed message, and are waiting on a
185 /// remote revoke_and_ack on a previous state before we can do so.
186 AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome),
187 /// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
188 /// the remote side hasn't yet revoked their previous state, which we need them to do before we
189 /// can do any backwards failing. Implies AwaitingRemoteRevoke.
190 /// We have removed this HTLC in our latest commitment_signed and are now just waiting on a
191 /// revoke_and_ack to drop completely.
192 AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome),
196 enum OutboundHTLCOutcome {
197 /// LDK version 0.0.105+ will always fill in the preimage here.
198 Success(Option<PaymentPreimage>),
199 Failure(HTLCFailReason),
202 impl From<Option<HTLCFailReason>> for OutboundHTLCOutcome {
203 fn from(o: Option<HTLCFailReason>) -> Self {
205 None => OutboundHTLCOutcome::Success(None),
206 Some(r) => OutboundHTLCOutcome::Failure(r)
211 impl<'a> Into<Option<&'a HTLCFailReason>> for &'a OutboundHTLCOutcome {
212 fn into(self) -> Option<&'a HTLCFailReason> {
214 OutboundHTLCOutcome::Success(_) => None,
215 OutboundHTLCOutcome::Failure(ref r) => Some(r)
220 struct OutboundHTLCOutput {
224 payment_hash: PaymentHash,
225 state: OutboundHTLCState,
227 skimmed_fee_msat: Option<u64>,
230 /// See AwaitingRemoteRevoke ChannelState for more info
231 enum HTLCUpdateAwaitingACK {
232 AddHTLC { // TODO: Time out if we're getting close to cltv_expiry
236 payment_hash: PaymentHash,
238 onion_routing_packet: msgs::OnionPacket,
239 // The extra fee we're skimming off the top of this HTLC.
240 skimmed_fee_msat: Option<u64>,
243 payment_preimage: PaymentPreimage,
248 err_packet: msgs::OnionErrorPacket,
252 /// There are a few "states" and then a number of flags which can be applied:
253 /// We first move through init with OurInitSent -> TheirInitSent -> FundingCreated -> FundingSent.
254 /// TheirChannelReady and OurChannelReady then get set on FundingSent, and when both are set we
255 /// move on to ChannelReady.
256 /// Note that PeerDisconnected can be set on both ChannelReady and FundingSent.
257 /// ChannelReady can then get all remaining flags set on it, until we finish shutdown, then we
258 /// move on to ShutdownComplete, at which point most calls into this channel are disallowed.
260 /// Implies we have (or are prepared to) send our open_channel/accept_channel message
261 OurInitSent = 1 << 0,
262 /// Implies we have received their open_channel/accept_channel message
263 TheirInitSent = 1 << 1,
264 /// We have sent funding_created and are awaiting a funding_signed to advance to FundingSent.
265 /// Note that this is nonsense for an inbound channel as we immediately generate funding_signed
266 /// upon receipt of funding_created, so simply skip this state.
268 /// Set when we have received/sent funding_created and funding_signed and are thus now waiting
269 /// on the funding transaction to confirm. The ChannelReady flags are set to indicate when we
270 /// and our counterparty consider the funding transaction confirmed.
272 /// Flag which can be set on FundingSent to indicate they sent us a channel_ready message.
273 /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelReady.
274 TheirChannelReady = 1 << 4,
275 /// Flag which can be set on FundingSent to indicate we sent them a channel_ready message.
276 /// Once both TheirChannelReady and OurChannelReady are set, state moves on to ChannelReady.
277 OurChannelReady = 1 << 5,
279 /// Flag which is set on ChannelReady and FundingSent indicating remote side is considered
280 /// "disconnected" and no updates are allowed until after we've done a channel_reestablish
282 PeerDisconnected = 1 << 7,
283 /// Flag which is set on ChannelReady, FundingCreated, and FundingSent indicating the user has
284 /// told us a ChannelMonitor update is pending async persistence somewhere and we should pause
285 /// sending any outbound messages until they've managed to finish.
286 MonitorUpdateInProgress = 1 << 8,
287 /// Flag which implies that we have sent a commitment_signed but are awaiting the responding
288 /// revoke_and_ack message. During this time period, we can't generate new commitment_signed
289 /// messages as then we will be unable to determine which HTLCs they included in their
290 /// revoke_and_ack implicit ACK, so instead we have to hold them away temporarily to be sent
292 /// Flag is set on ChannelReady.
293 AwaitingRemoteRevoke = 1 << 9,
294 /// Flag which is set on ChannelReady or FundingSent after receiving a shutdown message from
295 /// the remote end. If set, they may not add any new HTLCs to the channel, and we are expected
296 /// to respond with our own shutdown message when possible.
297 RemoteShutdownSent = 1 << 10,
298 /// Flag which is set on ChannelReady or FundingSent after sending a shutdown message. At this
299 /// point, we may not add any new HTLCs to the channel.
300 LocalShutdownSent = 1 << 11,
301 /// We've successfully negotiated a closing_signed dance. At this point ChannelManager is about
302 /// to drop us, but we store this anyway.
303 ShutdownComplete = 4096,
305 const BOTH_SIDES_SHUTDOWN_MASK: u32 = ChannelState::LocalShutdownSent as u32 | ChannelState::RemoteShutdownSent as u32;
306 const MULTI_STATE_FLAGS: u32 = BOTH_SIDES_SHUTDOWN_MASK | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32;
308 pub const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
310 pub const DEFAULT_MAX_HTLCS: u16 = 50;
312 pub(crate) fn commitment_tx_base_weight(channel_type_features: &ChannelTypeFeatures) -> u64 {
313 const COMMITMENT_TX_BASE_WEIGHT: u64 = 724;
314 const COMMITMENT_TX_BASE_ANCHOR_WEIGHT: u64 = 1124;
315 if channel_type_features.supports_anchors_zero_fee_htlc_tx() { COMMITMENT_TX_BASE_ANCHOR_WEIGHT } else { COMMITMENT_TX_BASE_WEIGHT }
319 const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
321 pub const COMMITMENT_TX_WEIGHT_PER_HTLC: u64 = 172;
323 pub const ANCHOR_OUTPUT_VALUE_SATOSHI: u64 = 330;
325 /// The percentage of the channel value `holder_max_htlc_value_in_flight_msat` used to be set to,
326 /// before this was made configurable. The percentage was made configurable in LDK 0.0.107,
327 /// although LDK 0.0.104+ enabled serialization of channels with a different value set for
328 /// `holder_max_htlc_value_in_flight_msat`.
329 pub const MAX_IN_FLIGHT_PERCENT_LEGACY: u8 = 10;
331 /// Maximum `funding_satoshis` value according to the BOLT #2 specification, if
332 /// `option_support_large_channel` (aka wumbo channels) is not supported.
334 pub const MAX_FUNDING_SATOSHIS_NO_WUMBO: u64 = (1 << 24) - 1;
336 /// Total bitcoin supply in satoshis.
337 pub const TOTAL_BITCOIN_SUPPLY_SATOSHIS: u64 = 21_000_000 * 1_0000_0000;
339 /// The maximum network dust limit for standard script formats. This currently represents the
340 /// minimum output value for a P2SH output before Bitcoin Core 22 considers the entire
341 /// transaction non-standard and thus refuses to relay it.
342 /// We also use this as the maximum counterparty `dust_limit_satoshis` allowed, given many
343 /// implementations use this value for their dust limit today.
344 pub const MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS: u64 = 546;
346 /// The maximum channel dust limit we will accept from our counterparty.
347 pub const MAX_CHAN_DUST_LIMIT_SATOSHIS: u64 = MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS;
349 /// The dust limit is used for both the commitment transaction outputs as well as the closing
350 /// transactions. For cooperative closing transactions, we require segwit outputs, though accept
351 /// *any* segwit scripts, which are allowed to be up to 42 bytes in length.
352 /// In order to avoid having to concern ourselves with standardness during the closing process, we
353 /// simply require our counterparty to use a dust limit which will leave any segwit output
355 /// See <https://github.com/lightning/bolts/issues/905> for more details.
356 pub const MIN_CHAN_DUST_LIMIT_SATOSHIS: u64 = 354;
358 // Just a reasonable implementation-specific safe lower bound, higher than the dust limit.
359 pub const MIN_THEIR_CHAN_RESERVE_SATOSHIS: u64 = 1000;
361 /// Used to return a simple Error back to ChannelManager. Will get converted to a
362 /// msgs::ErrorAction::SendErrorMessage or msgs::ErrorAction::IgnoreError as appropriate with our
363 /// channel_id in ChannelManager.
364 pub(super) enum ChannelError {
370 impl fmt::Debug for ChannelError {
371 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
373 &ChannelError::Ignore(ref e) => write!(f, "Ignore : {}", e),
374 &ChannelError::Warn(ref e) => write!(f, "Warn : {}", e),
375 &ChannelError::Close(ref e) => write!(f, "Close : {}", e),
380 impl fmt::Display for ChannelError {
381 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
383 &ChannelError::Ignore(ref e) => write!(f, "{}", e),
384 &ChannelError::Warn(ref e) => write!(f, "{}", e),
385 &ChannelError::Close(ref e) => write!(f, "{}", e),
390 macro_rules! secp_check {
391 ($res: expr, $err: expr) => {
394 Err(_) => return Err(ChannelError::Close($err)),
399 /// The "channel disabled" bit in channel_update must be set based on whether we are connected to
400 /// our counterparty or not. However, we don't want to announce updates right away to avoid
401 /// spamming the network with updates if the connection is flapping. Instead, we "stage" updates to
402 /// our channel_update message and track the current state here.
403 /// See implementation at [`super::channelmanager::ChannelManager::timer_tick_occurred`].
404 #[derive(Clone, Copy, PartialEq)]
405 pub(super) enum ChannelUpdateStatus {
406 /// We've announced the channel as enabled and are connected to our peer.
408 /// Our channel is no longer live, but we haven't announced the channel as disabled yet.
410 /// Our channel is live again, but we haven't announced the channel as enabled yet.
412 /// We've announced the channel as disabled.
416 /// We track when we sent an `AnnouncementSignatures` to our peer in a few states, described here.
418 pub enum AnnouncementSigsState {
419 /// We have not sent our peer an `AnnouncementSignatures` yet, or our peer disconnected since
420 /// we sent the last `AnnouncementSignatures`.
422 /// We sent an `AnnouncementSignatures` to our peer since the last time our peer disconnected.
423 /// This state never appears on disk - instead we write `NotSent`.
425 /// We sent a `CommitmentSigned` after the last `AnnouncementSignatures` we sent. Because we
426 /// only ever have a single `CommitmentSigned` pending at once, if we sent one after sending
427 /// `AnnouncementSignatures` then we know the peer received our `AnnouncementSignatures` if
428 /// they send back a `RevokeAndACK`.
429 /// This state never appears on disk - instead we write `NotSent`.
431 /// We received a `RevokeAndACK`, effectively ack-ing our `AnnouncementSignatures`, at this
432 /// point we no longer need to re-send our `AnnouncementSignatures` again on reconnect.
436 /// An enum indicating whether the local or remote side offered a given HTLC.
442 /// An enum gathering stats on pending HTLCs, either inbound or outbound side.
445 pending_htlcs_value_msat: u64,
446 on_counterparty_tx_dust_exposure_msat: u64,
447 on_holder_tx_dust_exposure_msat: u64,
448 holding_cell_msat: u64,
449 on_holder_tx_holding_cell_htlcs_count: u32, // dust HTLCs *non*-included
452 /// An enum gathering stats on commitment transaction, either local or remote.
453 struct CommitmentStats<'a> {
454 tx: CommitmentTransaction, // the transaction info
455 feerate_per_kw: u32, // the feerate included to build the transaction
456 total_fee_sat: u64, // the total fee included in the transaction
457 num_nondust_htlcs: usize, // the number of HTLC outputs (dust HTLCs *non*-included)
458 htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, // the list of HTLCs (dust HTLCs *included*) which were not ignored when building the transaction
459 local_balance_msat: u64, // local balance before fees but considering dust limits
460 remote_balance_msat: u64, // remote balance before fees but considering dust limits
461 preimages: Vec<PaymentPreimage>, // preimages for successful offered HTLCs since last commitment
464 /// Used when calculating whether we or the remote can afford an additional HTLC.
465 struct HTLCCandidate {
467 origin: HTLCInitiator,
471 fn new(amount_msat: u64, origin: HTLCInitiator) -> Self {
479 /// A return value enum for get_update_fulfill_htlc. See UpdateFulfillCommitFetch variants for
481 enum UpdateFulfillFetch {
483 monitor_update: ChannelMonitorUpdate,
484 htlc_value_msat: u64,
485 msg: Option<msgs::UpdateFulfillHTLC>,
490 /// The return type of get_update_fulfill_htlc_and_commit.
491 pub enum UpdateFulfillCommitFetch {
492 /// Indicates the HTLC fulfill is new, and either generated an update_fulfill message, placed
493 /// it in the holding cell, or re-generated the update_fulfill message after the same claim was
494 /// previously placed in the holding cell (and has since been removed).
496 /// The ChannelMonitorUpdate which places the new payment preimage in the channel monitor
497 monitor_update: ChannelMonitorUpdate,
498 /// The value of the HTLC which was claimed, in msat.
499 htlc_value_msat: u64,
501 /// Indicates the HTLC fulfill is duplicative and already existed either in the holding cell
502 /// or has been forgotten (presumably previously claimed).
506 /// The return value of `monitor_updating_restored`
507 pub(super) struct MonitorRestoreUpdates {
508 pub raa: Option<msgs::RevokeAndACK>,
509 pub commitment_update: Option<msgs::CommitmentUpdate>,
510 pub order: RAACommitmentOrder,
511 pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
512 pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
513 pub finalized_claimed_htlcs: Vec<HTLCSource>,
514 pub funding_broadcastable: Option<Transaction>,
515 pub channel_ready: Option<msgs::ChannelReady>,
516 pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
519 /// The return value of `channel_reestablish`
520 pub(super) struct ReestablishResponses {
521 pub channel_ready: Option<msgs::ChannelReady>,
522 pub raa: Option<msgs::RevokeAndACK>,
523 pub commitment_update: Option<msgs::CommitmentUpdate>,
524 pub order: RAACommitmentOrder,
525 pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
526 pub shutdown_msg: Option<msgs::Shutdown>,
529 /// The return type of `force_shutdown`
530 pub(crate) type ShutdownResult = (
531 Option<(PublicKey, OutPoint, ChannelMonitorUpdate)>,
532 Vec<(HTLCSource, PaymentHash, PublicKey, [u8; 32])>
535 /// If the majority of the channels funds are to the fundee and the initiator holds only just
536 /// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
537 /// initiator controls the feerate, if they then go to increase the channel fee, they may have no
538 /// balance but the fundee is unable to send a payment as the increase in fee more than drains
539 /// their reserve value. Thus, neither side can send a new HTLC and the channel becomes useless.
540 /// Thus, before sending an HTLC when we are the initiator, we check that the feerate can increase
541 /// by this multiple without hitting this case, before sending.
542 /// This multiple is effectively the maximum feerate "jump" we expect until more HTLCs flow over
543 /// the channel. Sadly, there isn't really a good number for this - if we expect to have no new
544 /// HTLCs for days we may need this to suffice for feerate increases across days, but that may
545 /// leave the channel less usable as we hold a bigger reserve.
546 #[cfg(any(fuzzing, test))]
547 pub const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
548 #[cfg(not(any(fuzzing, test)))]
549 const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
551 /// If we fail to see a funding transaction confirmed on-chain within this many blocks after the
552 /// channel creation on an inbound channel, we simply force-close and move on.
553 /// This constant is the one suggested in BOLT 2.
554 pub(crate) const FUNDING_CONF_DEADLINE_BLOCKS: u32 = 2016;
556 /// In case of a concurrent update_add_htlc proposed by our counterparty, we might
557 /// not have enough balance value remaining to cover the onchain cost of this new
558 /// HTLC weight. If this happens, our counterparty fails the reception of our
559 /// commitment_signed including this new HTLC due to infringement on the channel
561 /// To prevent this case, we compute our outbound update_fee with an HTLC buffer of
562 /// size 2. However, if the number of concurrent update_add_htlc is higher, this still
563 /// leads to a channel force-close. Ultimately, this is an issue coming from the
564 /// design of LN state machines, allowing asynchronous updates.
565 pub(crate) const CONCURRENT_INBOUND_HTLC_FEE_BUFFER: u32 = 2;
567 /// When a channel is opened, we check that the funding amount is enough to pay for relevant
568 /// commitment transaction fees, with at least this many HTLCs present on the commitment
569 /// transaction (not counting the value of the HTLCs themselves).
570 pub(crate) const MIN_AFFORDABLE_HTLC_COUNT: usize = 4;
572 /// When a [`Channel`] has its [`ChannelConfig`] updated, its existing one is stashed for up to this
573 /// number of ticks to allow forwarding HTLCs by nodes that have yet to receive the new
574 /// ChannelUpdate prompted by the config update. This value was determined as follows:
576 /// * The expected interval between ticks (1 minute).
577 /// * The average convergence delay of updates across the network, i.e., ~300 seconds on average
578 /// for a node to see an update as seen on `<https://arxiv.org/pdf/2205.12737.pdf>`.
579 /// * `EXPIRE_PREV_CONFIG_TICKS` = convergence_delay / tick_interval
580 pub(crate) const EXPIRE_PREV_CONFIG_TICKS: usize = 5;
582 /// The number of ticks that may elapse while we're waiting for a response to a
583 /// [`msgs::RevokeAndACK`] or [`msgs::ChannelReestablish`] message before we attempt to disconnect
586 /// See [`ChannelContext::sent_message_awaiting_response`] for more information.
587 pub(crate) const DISCONNECT_PEER_AWAITING_RESPONSE_TICKS: usize = 2;
589 struct PendingChannelMonitorUpdate {
590 update: ChannelMonitorUpdate,
593 impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
594 (0, update, required),
597 /// Contains everything about the channel including state, and various flags.
598 pub(super) struct ChannelContext<Signer: ChannelSigner> {
599 config: LegacyChannelConfig,
601 // Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
602 // constructed using it. The second element in the tuple corresponds to the number of ticks that
603 // have elapsed since the update occurred.
604 prev_config: Option<(ChannelConfig, usize)>,
606 inbound_handshake_limits_override: Option<ChannelHandshakeLimits>,
610 channel_id: [u8; 32],
611 temporary_channel_id: Option<[u8; 32]>, // Will be `None` for channels created prior to 0.0.115.
614 // When we reach max(6 blocks, minimum_depth), we need to send an AnnouncementSigs message to
615 // our peer. However, we want to make sure they received it, or else rebroadcast it when we
617 // We do so here, see `AnnouncementSigsSent` for more details on the state(s).
618 // Note that a number of our tests were written prior to the behavior here which retransmits
619 // AnnouncementSignatures until after an RAA completes, so the behavior is short-circuited in
621 #[cfg(any(test, feature = "_test_utils"))]
622 pub(crate) announcement_sigs_state: AnnouncementSigsState,
623 #[cfg(not(any(test, feature = "_test_utils")))]
624 announcement_sigs_state: AnnouncementSigsState,
626 secp_ctx: Secp256k1<secp256k1::All>,
627 channel_value_satoshis: u64,
629 latest_monitor_update_id: u64,
631 holder_signer: Signer,
632 shutdown_scriptpubkey: Option<ShutdownScript>,
633 destination_script: Script,
635 // Our commitment numbers start at 2^48-1 and count down, whereas the ones used in transaction
636 // generation start at 0 and count up...this simplifies some parts of implementation at the
637 // cost of others, but should really just be changed.
639 cur_holder_commitment_transaction_number: u64,
640 cur_counterparty_commitment_transaction_number: u64,
641 value_to_self_msat: u64, // Excluding all pending_htlcs, excluding fees
642 pending_inbound_htlcs: Vec<InboundHTLCOutput>,
643 pending_outbound_htlcs: Vec<OutboundHTLCOutput>,
644 holding_cell_htlc_updates: Vec<HTLCUpdateAwaitingACK>,
646 /// When resending CS/RAA messages on channel monitor restoration or on reconnect, we always
647 /// need to ensure we resend them in the order we originally generated them. Note that because
648 /// there can only ever be one in-flight CS and/or one in-flight RAA at any time, it is
649 /// sufficient to simply set this to the opposite of any message we are generating as we
650 /// generate it. ie when we generate a CS, we set this to RAAFirst as, if there is a pending
651 /// in-flight RAA to resend, it will have been the first thing we generated, and thus we should
653 resend_order: RAACommitmentOrder,
655 monitor_pending_channel_ready: bool,
656 monitor_pending_revoke_and_ack: bool,
657 monitor_pending_commitment_signed: bool,
659 // TODO: If a channel is drop'd, we don't know whether the `ChannelMonitor` is ultimately
660 // responsible for some of the HTLCs here or not - we don't know whether the update in question
661 // completed or not. We currently ignore these fields entirely when force-closing a channel,
662 // but need to handle this somehow or we run the risk of losing HTLCs!
663 monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
664 monitor_pending_failures: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
665 monitor_pending_finalized_fulfills: Vec<HTLCSource>,
667 // pending_update_fee is filled when sending and receiving update_fee.
669 // Because it follows the same commitment flow as HTLCs, `FeeUpdateState` is either `Outbound`
670 // or matches a subset of the `InboundHTLCOutput` variants. It is then updated/used when
671 // generating new commitment transactions with exactly the same criteria as inbound/outbound
672 // HTLCs with similar state.
673 pending_update_fee: Option<(u32, FeeUpdateState)>,
674 // If a `send_update_fee()` call is made with ChannelState::AwaitingRemoteRevoke set, we place
675 // it here instead of `pending_update_fee` in the same way as we place outbound HTLC updates in
676 // `holding_cell_htlc_updates` instead of `pending_outbound_htlcs`. It is released into
677 // `pending_update_fee` with the same criteria as outbound HTLC updates but can be updated by
678 // further `send_update_fee` calls, dropping the previous holding cell update entirely.
679 holding_cell_update_fee: Option<u32>,
680 next_holder_htlc_id: u64,
681 next_counterparty_htlc_id: u64,
684 /// The timestamp set on our latest `channel_update` message for this channel. It is updated
685 /// when the channel is updated in ways which may impact the `channel_update` message or when a
686 /// new block is received, ensuring it's always at least moderately close to the current real
688 update_time_counter: u32,
690 #[cfg(debug_assertions)]
691 /// Max to_local and to_remote outputs in a locally-generated commitment transaction
692 holder_max_commitment_tx_output: Mutex<(u64, u64)>,
693 #[cfg(debug_assertions)]
694 /// Max to_local and to_remote outputs in a remote-generated commitment transaction
695 counterparty_max_commitment_tx_output: Mutex<(u64, u64)>,
697 last_sent_closing_fee: Option<(u64, Signature)>, // (fee, holder_sig)
698 target_closing_feerate_sats_per_kw: Option<u32>,
700 /// If our counterparty sent us a closing_signed while we were waiting for a `ChannelMonitor`
701 /// update, we need to delay processing it until later. We do that here by simply storing the
702 /// closing_signed message and handling it in `maybe_propose_closing_signed`.
703 pending_counterparty_closing_signed: Option<msgs::ClosingSigned>,
705 /// The minimum and maximum absolute fee, in satoshis, we are willing to place on the closing
706 /// transaction. These are set once we reach `closing_negotiation_ready`.
708 pub(crate) closing_fee_limits: Option<(u64, u64)>,
710 closing_fee_limits: Option<(u64, u64)>,
712 /// Flag that ensures that `accept_inbound_channel` must be called before `funding_created`
713 /// is executed successfully. The reason for this flag is that when the
714 /// `UserConfig::manually_accept_inbound_channels` config flag is set to true, inbound channels
715 /// are required to be manually accepted by the node operator before the `msgs::AcceptChannel`
716 /// message is created and sent out. During the manual accept process, `accept_inbound_channel`
717 /// is called by `ChannelManager::accept_inbound_channel`.
719 /// The flag counteracts that a counterparty node could theoretically send a
720 /// `msgs::FundingCreated` message before the node operator has manually accepted an inbound
721 /// channel request made by the counterparty node. That would execute `funding_created` before
722 /// `accept_inbound_channel`, and `funding_created` should therefore not execute successfully.
723 inbound_awaiting_accept: bool,
725 /// The hash of the block in which the funding transaction was included.
726 funding_tx_confirmed_in: Option<BlockHash>,
727 funding_tx_confirmation_height: u32,
728 short_channel_id: Option<u64>,
729 /// Either the height at which this channel was created or the height at which it was last
730 /// serialized if it was serialized by versions prior to 0.0.103.
731 /// We use this to close if funding is never broadcasted.
732 channel_creation_height: u32,
734 counterparty_dust_limit_satoshis: u64,
737 pub(super) holder_dust_limit_satoshis: u64,
739 holder_dust_limit_satoshis: u64,
742 pub(super) counterparty_max_htlc_value_in_flight_msat: u64,
744 counterparty_max_htlc_value_in_flight_msat: u64,
747 pub(super) holder_max_htlc_value_in_flight_msat: u64,
749 holder_max_htlc_value_in_flight_msat: u64,
751 /// minimum channel reserve for self to maintain - set by them.
752 counterparty_selected_channel_reserve_satoshis: Option<u64>,
755 pub(super) holder_selected_channel_reserve_satoshis: u64,
757 holder_selected_channel_reserve_satoshis: u64,
759 counterparty_htlc_minimum_msat: u64,
760 holder_htlc_minimum_msat: u64,
762 pub counterparty_max_accepted_htlcs: u16,
764 counterparty_max_accepted_htlcs: u16,
765 holder_max_accepted_htlcs: u16,
766 minimum_depth: Option<u32>,
768 counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,
770 pub(crate) channel_transaction_parameters: ChannelTransactionParameters,
771 funding_transaction: Option<Transaction>,
773 counterparty_cur_commitment_point: Option<PublicKey>,
774 counterparty_prev_commitment_point: Option<PublicKey>,
775 counterparty_node_id: PublicKey,
777 counterparty_shutdown_scriptpubkey: Option<Script>,
779 commitment_secrets: CounterpartyCommitmentSecrets,
781 channel_update_status: ChannelUpdateStatus,
782 /// Once we reach `closing_negotiation_ready`, we set this, indicating if closing_signed does
783 /// not complete within a single timer tick (one minute), we should force-close the channel.
784 /// This prevents us from keeping unusable channels around forever if our counterparty wishes
786 /// Note that this field is reset to false on deserialization to give us a chance to connect to
787 /// our peer and start the closing_signed negotiation fresh.
788 closing_signed_in_flight: bool,
790 /// Our counterparty's channel_announcement signatures provided in announcement_signatures.
791 /// This can be used to rebroadcast the channel_announcement message later.
792 announcement_sigs: Option<(Signature, Signature)>,
794 // We save these values so we can make sure `next_local_commit_tx_fee_msat` and
795 // `next_remote_commit_tx_fee_msat` properly predict what the next commitment transaction fee will
796 // be, by comparing the cached values to the fee of the tranaction generated by
797 // `build_commitment_transaction`.
798 #[cfg(any(test, fuzzing))]
799 next_local_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
800 #[cfg(any(test, fuzzing))]
801 next_remote_commitment_tx_fee_info_cached: Mutex<Option<CommitmentTxInfoCached>>,
803 /// lnd has a long-standing bug where, upon reconnection, if the channel is not yet confirmed
804 /// they will not send a channel_reestablish until the channel locks in. Then, they will send a
805 /// channel_ready *before* sending the channel_reestablish (which is clearly a violation of
806 /// the BOLT specs). We copy c-lightning's workaround here and simply store the channel_ready
807 /// message until we receive a channel_reestablish.
809 /// See-also <https://github.com/lightningnetwork/lnd/issues/4006>
810 pub workaround_lnd_bug_4006: Option<msgs::ChannelReady>,
812 /// An option set when we wish to track how many ticks have elapsed while waiting for a response
813 /// from our counterparty after sending a message. If the peer has yet to respond after reaching
814 /// `DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`, a reconnection should be attempted to try to
815 /// unblock the state machine.
817 /// This behavior is mostly motivated by a lnd bug in which we don't receive a message we expect
818 /// to in a timely manner, which may lead to channels becoming unusable and/or force-closed. An
819 /// example of such can be found at <https://github.com/lightningnetwork/lnd/issues/7682>.
821 /// This is currently only used when waiting for a [`msgs::ChannelReestablish`] or
822 /// [`msgs::RevokeAndACK`] message from the counterparty.
823 sent_message_awaiting_response: Option<usize>,
825 #[cfg(any(test, fuzzing))]
826 // When we receive an HTLC fulfill on an outbound path, we may immediately fulfill the
827 // corresponding HTLC on the inbound path. If, then, the outbound path channel is
828 // disconnected and reconnected (before we've exchange commitment_signed and revoke_and_ack
829 // messages), they may re-broadcast their update_fulfill_htlc, causing a duplicate claim. This
830 // is fine, but as a sanity check in our failure to generate the second claim, we check here
831 // that the original was a claim, and that we aren't now trying to fulfill a failed HTLC.
832 historical_inbound_htlc_fulfills: HashSet<u64>,
834 /// This channel's type, as negotiated during channel open
835 channel_type: ChannelTypeFeatures,
837 // Our counterparty can offer us SCID aliases which they will map to this channel when routing
838 // outbound payments. These can be used in invoice route hints to avoid explicitly revealing
839 // the channel's funding UTXO.
841 // We also use this when sending our peer a channel_update that isn't to be broadcasted
842 // publicly - allowing them to re-use their map of SCID -> channel for channel_update ->
843 // associated channel mapping.
845 // We only bother storing the most recent SCID alias at any time, though our counterparty has
846 // to store all of them.
847 latest_inbound_scid_alias: Option<u64>,
849 // We always offer our counterparty a static SCID alias, which we recognize as for this channel
850 // if we see it in HTLC forwarding instructions. We don't bother rotating the alias given we
851 // don't currently support node id aliases and eventually privacy should be provided with
852 // blinded paths instead of simple scid+node_id aliases.
853 outbound_scid_alias: u64,
855 // We track whether we already emitted a `ChannelPending` event.
856 channel_pending_event_emitted: bool,
858 // We track whether we already emitted a `ChannelReady` event.
859 channel_ready_event_emitted: bool,
861 /// The unique identifier used to re-derive the private key material for the channel through
862 /// [`SignerProvider::derive_channel_signer`].
863 channel_keys_id: [u8; 32],
865 /// If we can't release a [`ChannelMonitorUpdate`] until some external action completes, we
866 /// store it here and only release it to the `ChannelManager` once it asks for it.
867 blocked_monitor_updates: Vec<PendingChannelMonitorUpdate>,
870 impl<Signer: ChannelSigner> ChannelContext<Signer> {
871 /// Allowed in any state (including after shutdown)
872 pub fn get_update_time_counter(&self) -> u32 {
873 self.update_time_counter
876 pub fn get_latest_monitor_update_id(&self) -> u64 {
877 self.latest_monitor_update_id
880 pub fn should_announce(&self) -> bool {
881 self.config.announced_channel
884 pub fn is_outbound(&self) -> bool {
885 self.channel_transaction_parameters.is_outbound_from_holder
888 /// Gets the fee we'd want to charge for adding an HTLC output to this Channel
889 /// Allowed in any state (including after shutdown)
890 pub fn get_outbound_forwarding_fee_base_msat(&self) -> u32 {
891 self.config.options.forwarding_fee_base_msat
894 /// Returns true if we've ever received a message from the remote end for this Channel
895 pub fn have_received_message(&self) -> bool {
896 self.channel_state > (ChannelState::OurInitSent as u32)
899 /// Returns true if this channel is fully established and not known to be closing.
900 /// Allowed in any state (including after shutdown)
901 pub fn is_usable(&self) -> bool {
902 let mask = ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK;
903 (self.channel_state & mask) == (ChannelState::ChannelReady as u32) && !self.monitor_pending_channel_ready
906 /// Returns true if this channel is currently available for use. This is a superset of
907 /// is_usable() and considers things like the channel being temporarily disabled.
908 /// Allowed in any state (including after shutdown)
909 pub fn is_live(&self) -> bool {
910 self.is_usable() && (self.channel_state & (ChannelState::PeerDisconnected as u32) == 0)
915 pub fn channel_id(&self) -> [u8; 32] {
919 // Return the `temporary_channel_id` used during channel establishment.
921 // Will return `None` for channels created prior to LDK version 0.0.115.
922 pub fn temporary_channel_id(&self) -> Option<[u8; 32]> {
923 self.temporary_channel_id
926 pub fn minimum_depth(&self) -> Option<u32> {
930 /// Gets the "user_id" value passed into the construction of this channel. It has no special
931 /// meaning and exists only to allow users to have a persistent identifier of a channel.
932 pub fn get_user_id(&self) -> u128 {
936 /// Gets the channel's type
937 pub fn get_channel_type(&self) -> &ChannelTypeFeatures {
941 /// Guaranteed to be Some after both ChannelReady messages have been exchanged (and, thus,
942 /// is_usable() returns true).
943 /// Allowed in any state (including after shutdown)
944 pub fn get_short_channel_id(&self) -> Option<u64> {
945 self.short_channel_id
948 /// Allowed in any state (including after shutdown)
949 pub fn latest_inbound_scid_alias(&self) -> Option<u64> {
950 self.latest_inbound_scid_alias
953 /// Allowed in any state (including after shutdown)
954 pub fn outbound_scid_alias(&self) -> u64 {
955 self.outbound_scid_alias
958 /// Only allowed immediately after deserialization if get_outbound_scid_alias returns 0,
959 /// indicating we were written by LDK prior to 0.0.106 which did not set outbound SCID aliases.
960 pub fn set_outbound_scid_alias(&mut self, outbound_scid_alias: u64) {
961 assert_eq!(self.outbound_scid_alias, 0);
962 self.outbound_scid_alias = outbound_scid_alias;
965 /// Returns the funding_txo we either got from our peer, or were given by
966 /// get_outbound_funding_created.
967 pub fn get_funding_txo(&self) -> Option<OutPoint> {
968 self.channel_transaction_parameters.funding_outpoint
971 /// Returns the block hash in which our funding transaction was confirmed.
972 pub fn get_funding_tx_confirmed_in(&self) -> Option<BlockHash> {
973 self.funding_tx_confirmed_in
976 /// Returns the current number of confirmations on the funding transaction.
977 pub fn get_funding_tx_confirmations(&self, height: u32) -> u32 {
978 if self.funding_tx_confirmation_height == 0 {
979 // We either haven't seen any confirmation yet, or observed a reorg.
983 height.checked_sub(self.funding_tx_confirmation_height).map_or(0, |c| c + 1)
986 fn get_holder_selected_contest_delay(&self) -> u16 {
987 self.channel_transaction_parameters.holder_selected_contest_delay
990 fn get_holder_pubkeys(&self) -> &ChannelPublicKeys {
991 &self.channel_transaction_parameters.holder_pubkeys
994 pub fn get_counterparty_selected_contest_delay(&self) -> Option<u16> {
995 self.channel_transaction_parameters.counterparty_parameters
996 .as_ref().map(|params| params.selected_contest_delay)
999 fn get_counterparty_pubkeys(&self) -> &ChannelPublicKeys {
1000 &self.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
1003 /// Allowed in any state (including after shutdown)
1004 pub fn get_counterparty_node_id(&self) -> PublicKey {
1005 self.counterparty_node_id
1008 /// Allowed in any state (including after shutdown)
1009 pub fn get_holder_htlc_minimum_msat(&self) -> u64 {
1010 self.holder_htlc_minimum_msat
1013 /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
1014 pub fn get_holder_htlc_maximum_msat(&self) -> Option<u64> {
1015 self.get_htlc_maximum_msat(self.holder_max_htlc_value_in_flight_msat)
1018 /// Allowed in any state (including after shutdown)
1019 pub fn get_announced_htlc_max_msat(&self) -> u64 {
1021 // Upper bound by capacity. We make it a bit less than full capacity to prevent attempts
1022 // to use full capacity. This is an effort to reduce routing failures, because in many cases
1023 // channel might have been used to route very small values (either by honest users or as DoS).
1024 self.channel_value_satoshis * 1000 * 9 / 10,
1026 self.counterparty_max_htlc_value_in_flight_msat
1030 /// Allowed in any state (including after shutdown)
1031 pub fn get_counterparty_htlc_minimum_msat(&self) -> u64 {
1032 self.counterparty_htlc_minimum_msat
1035 /// Allowed in any state (including after shutdown), but will return none before TheirInitSent
1036 pub fn get_counterparty_htlc_maximum_msat(&self) -> Option<u64> {
1037 self.get_htlc_maximum_msat(self.counterparty_max_htlc_value_in_flight_msat)
1040 fn get_htlc_maximum_msat(&self, party_max_htlc_value_in_flight_msat: u64) -> Option<u64> {
1041 self.counterparty_selected_channel_reserve_satoshis.map(|counterparty_reserve| {
1042 let holder_reserve = self.holder_selected_channel_reserve_satoshis;
1044 (self.channel_value_satoshis - counterparty_reserve - holder_reserve) * 1000,
1045 party_max_htlc_value_in_flight_msat
1050 pub fn get_value_satoshis(&self) -> u64 {
1051 self.channel_value_satoshis
1054 pub fn get_fee_proportional_millionths(&self) -> u32 {
1055 self.config.options.forwarding_fee_proportional_millionths
1058 pub fn get_cltv_expiry_delta(&self) -> u16 {
1059 cmp::max(self.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
1062 pub fn get_max_dust_htlc_exposure_msat(&self) -> u64 {
1063 match self.config.options.max_dust_htlc_exposure {
1064 MaxDustHTLCExposure::FixedLimitMsat(limit) => limit,
1065 MaxDustHTLCExposure::FeeRateMultiplier(_) => 5_000_000,
1069 /// Returns the previous [`ChannelConfig`] applied to this channel, if any.
1070 pub fn prev_config(&self) -> Option<ChannelConfig> {
1071 self.prev_config.map(|prev_config| prev_config.0)
1074 // Checks whether we should emit a `ChannelPending` event.
1075 pub(crate) fn should_emit_channel_pending_event(&mut self) -> bool {
1076 self.is_funding_initiated() && !self.channel_pending_event_emitted
1079 // Returns whether we already emitted a `ChannelPending` event.
1080 pub(crate) fn channel_pending_event_emitted(&self) -> bool {
1081 self.channel_pending_event_emitted
1084 // Remembers that we already emitted a `ChannelPending` event.
1085 pub(crate) fn set_channel_pending_event_emitted(&mut self) {
1086 self.channel_pending_event_emitted = true;
1089 // Checks whether we should emit a `ChannelReady` event.
1090 pub(crate) fn should_emit_channel_ready_event(&mut self) -> bool {
1091 self.is_usable() && !self.channel_ready_event_emitted
1094 // Remembers that we already emitted a `ChannelReady` event.
1095 pub(crate) fn set_channel_ready_event_emitted(&mut self) {
1096 self.channel_ready_event_emitted = true;
1099 /// Tracks the number of ticks elapsed since the previous [`ChannelConfig`] was updated. Once
1100 /// [`EXPIRE_PREV_CONFIG_TICKS`] is reached, the previous config is considered expired and will
1101 /// no longer be considered when forwarding HTLCs.
1102 pub fn maybe_expire_prev_config(&mut self) {
1103 if self.prev_config.is_none() {
1106 let prev_config = self.prev_config.as_mut().unwrap();
1108 if prev_config.1 == EXPIRE_PREV_CONFIG_TICKS {
1109 self.prev_config = None;
1113 /// Returns the current [`ChannelConfig`] applied to the channel.
1114 pub fn config(&self) -> ChannelConfig {
1118 /// Updates the channel's config. A bool is returned indicating whether the config update
1119 /// applied resulted in a new ChannelUpdate message.
1120 pub fn update_config(&mut self, config: &ChannelConfig) -> bool {
1121 let did_channel_update =
1122 self.config.options.forwarding_fee_proportional_millionths != config.forwarding_fee_proportional_millionths ||
1123 self.config.options.forwarding_fee_base_msat != config.forwarding_fee_base_msat ||
1124 self.config.options.cltv_expiry_delta != config.cltv_expiry_delta;
1125 if did_channel_update {
1126 self.prev_config = Some((self.config.options, 0));
1127 // Update the counter, which backs the ChannelUpdate timestamp, to allow the relay
1128 // policy change to propagate throughout the network.
1129 self.update_time_counter += 1;
1131 self.config.options = *config;
1135 /// Returns true if funding_created was sent/received.
1136 pub fn is_funding_initiated(&self) -> bool {
1137 self.channel_state >= ChannelState::FundingSent as u32
1140 /// Transaction nomenclature is somewhat confusing here as there are many different cases - a
1141 /// transaction is referred to as "a's transaction" implying that a will be able to broadcast
1142 /// the transaction. Thus, b will generally be sending a signature over such a transaction to
1143 /// a, and a can revoke the transaction by providing b the relevant per_commitment_secret. As
1144 /// such, a transaction is generally the result of b increasing the amount paid to a (or adding
1146 /// @local is used only to convert relevant internal structures which refer to remote vs local
1147 /// to decide value of outputs and direction of HTLCs.
1148 /// @generated_by_local is used to determine *which* HTLCs to include - noting that the HTLC
1149 /// state may indicate that one peer has informed the other that they'd like to add an HTLC but
1150 /// have not yet committed it. Such HTLCs will only be included in transactions which are being
1151 /// generated by the peer which proposed adding the HTLCs, and thus we need to understand both
1152 /// which peer generated this transaction and "to whom" this transaction flows.
1154 fn build_commitment_transaction<L: Deref>(&self, commitment_number: u64, keys: &TxCreationKeys, local: bool, generated_by_local: bool, logger: &L) -> CommitmentStats
1155 where L::Target: Logger
1157 let mut included_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::new();
1158 let num_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
1159 let mut included_non_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
1161 let broadcaster_dust_limit_satoshis = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
1162 let mut remote_htlc_total_msat = 0;
1163 let mut local_htlc_total_msat = 0;
1164 let mut value_to_self_msat_offset = 0;
1166 let mut feerate_per_kw = self.feerate_per_kw;
1167 if let Some((feerate, update_state)) = self.pending_update_fee {
1168 if match update_state {
1169 // Note that these match the inclusion criteria when scanning
1170 // pending_inbound_htlcs below.
1171 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.is_outbound()); !generated_by_local },
1172 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => { debug_assert!(!self.is_outbound()); !generated_by_local },
1173 FeeUpdateState::Outbound => { assert!(self.is_outbound()); generated_by_local },
1175 feerate_per_kw = feerate;
1179 log_trace!(logger, "Building commitment transaction number {} (really {} xor {}) for channel {} for {}, generated by {} with fee {}...",
1180 commitment_number, (INITIAL_COMMITMENT_NUMBER - commitment_number),
1181 get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()),
1182 log_bytes!(self.channel_id), if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);
1184 macro_rules! get_htlc_in_commitment {
1185 ($htlc: expr, $offered: expr) => {
1186 HTLCOutputInCommitment {
1188 amount_msat: $htlc.amount_msat,
1189 cltv_expiry: $htlc.cltv_expiry,
1190 payment_hash: $htlc.payment_hash,
1191 transaction_output_index: None
1196 macro_rules! add_htlc_output {
1197 ($htlc: expr, $outbound: expr, $source: expr, $state_name: expr) => {
1198 if $outbound == local { // "offered HTLC output"
1199 let htlc_in_tx = get_htlc_in_commitment!($htlc, true);
1200 let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1203 feerate_per_kw as u64 * htlc_timeout_tx_weight(self.get_channel_type()) / 1000
1205 if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1206 log_trace!(logger, " ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1207 included_non_dust_htlcs.push((htlc_in_tx, $source));
1209 log_trace!(logger, " ...including {} {} dust HTLC {} (hash {}) with value {} due to dust limit", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1210 included_dust_htlcs.push((htlc_in_tx, $source));
1213 let htlc_in_tx = get_htlc_in_commitment!($htlc, false);
1214 let htlc_tx_fee = if self.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1217 feerate_per_kw as u64 * htlc_success_tx_weight(self.get_channel_type()) / 1000
1219 if $htlc.amount_msat / 1000 >= broadcaster_dust_limit_satoshis + htlc_tx_fee {
1220 log_trace!(logger, " ...including {} {} HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1221 included_non_dust_htlcs.push((htlc_in_tx, $source));
1223 log_trace!(logger, " ...including {} {} dust HTLC {} (hash {}) with value {}", if $outbound { "outbound" } else { "inbound" }, $state_name, $htlc.htlc_id, log_bytes!($htlc.payment_hash.0), $htlc.amount_msat);
1224 included_dust_htlcs.push((htlc_in_tx, $source));
1230 for ref htlc in self.pending_inbound_htlcs.iter() {
1231 let (include, state_name) = match htlc.state {
1232 InboundHTLCState::RemoteAnnounced(_) => (!generated_by_local, "RemoteAnnounced"),
1233 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => (!generated_by_local, "AwaitingRemoteRevokeToAnnounce"),
1234 InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => (true, "AwaitingAnnouncedRemoteRevoke"),
1235 InboundHTLCState::Committed => (true, "Committed"),
1236 InboundHTLCState::LocalRemoved(_) => (!generated_by_local, "LocalRemoved"),
1240 add_htlc_output!(htlc, false, None, state_name);
1241 remote_htlc_total_msat += htlc.amount_msat;
1243 log_trace!(logger, " ...not including inbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, log_bytes!(htlc.payment_hash.0), htlc.amount_msat, state_name);
1245 &InboundHTLCState::LocalRemoved(ref reason) => {
1246 if generated_by_local {
1247 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
1248 value_to_self_msat_offset += htlc.amount_msat as i64;
1257 let mut preimages: Vec<PaymentPreimage> = Vec::new();
1259 for ref htlc in self.pending_outbound_htlcs.iter() {
1260 let (include, state_name) = match htlc.state {
1261 OutboundHTLCState::LocalAnnounced(_) => (generated_by_local, "LocalAnnounced"),
1262 OutboundHTLCState::Committed => (true, "Committed"),
1263 OutboundHTLCState::RemoteRemoved(_) => (generated_by_local, "RemoteRemoved"),
1264 OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) => (generated_by_local, "AwaitingRemoteRevokeToRemove"),
1265 OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => (false, "AwaitingRemovedRemoteRevoke"),
1268 let preimage_opt = match htlc.state {
1269 OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(p)) => p,
1270 OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(p)) => p,
1271 OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(p)) => p,
1275 if let Some(preimage) = preimage_opt {
1276 preimages.push(preimage);
1280 add_htlc_output!(htlc, true, Some(&htlc.source), state_name);
1281 local_htlc_total_msat += htlc.amount_msat;
1283 log_trace!(logger, " ...not including outbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, log_bytes!(htlc.payment_hash.0), htlc.amount_msat, state_name);
1285 OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_))|OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) => {
1286 value_to_self_msat_offset -= htlc.amount_msat as i64;
1288 OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(_)) => {
1289 if !generated_by_local {
1290 value_to_self_msat_offset -= htlc.amount_msat as i64;
1298 let mut value_to_self_msat: i64 = (self.value_to_self_msat - local_htlc_total_msat) as i64 + value_to_self_msat_offset;
1299 assert!(value_to_self_msat >= 0);
1300 // Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
1301 // AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
1302 // "violate" their reserve value by couting those against it. Thus, we have to convert
1303 // everything to i64 before subtracting as otherwise we can overflow.
1304 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;
1305 assert!(value_to_remote_msat >= 0);
1307 #[cfg(debug_assertions)]
1309 // Make sure that the to_self/to_remote is always either past the appropriate
1310 // channel_reserve *or* it is making progress towards it.
1311 let mut broadcaster_max_commitment_tx_output = if generated_by_local {
1312 self.holder_max_commitment_tx_output.lock().unwrap()
1314 self.counterparty_max_commitment_tx_output.lock().unwrap()
1316 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);
1317 broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, value_to_self_msat as u64);
1318 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);
1319 broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, value_to_remote_msat as u64);
1322 let total_fee_sat = commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), &self.channel_transaction_parameters.channel_type_features);
1323 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;
1324 let (value_to_self, value_to_remote) = if self.is_outbound() {
1325 (value_to_self_msat / 1000 - anchors_val - total_fee_sat as i64, value_to_remote_msat / 1000)
1327 (value_to_self_msat / 1000, value_to_remote_msat / 1000 - anchors_val - total_fee_sat as i64)
1330 let mut value_to_a = if local { value_to_self } else { value_to_remote };
1331 let mut value_to_b = if local { value_to_remote } else { value_to_self };
1332 let (funding_pubkey_a, funding_pubkey_b) = if local {
1333 (self.get_holder_pubkeys().funding_pubkey, self.get_counterparty_pubkeys().funding_pubkey)
1335 (self.get_counterparty_pubkeys().funding_pubkey, self.get_holder_pubkeys().funding_pubkey)
1338 if value_to_a >= (broadcaster_dust_limit_satoshis as i64) {
1339 log_trace!(logger, " ...including {} output with value {}", if local { "to_local" } else { "to_remote" }, value_to_a);
1344 if value_to_b >= (broadcaster_dust_limit_satoshis as i64) {
1345 log_trace!(logger, " ...including {} output with value {}", if local { "to_remote" } else { "to_local" }, value_to_b);
1350 let num_nondust_htlcs = included_non_dust_htlcs.len();
1352 let channel_parameters =
1353 if local { self.channel_transaction_parameters.as_holder_broadcastable() }
1354 else { self.channel_transaction_parameters.as_counterparty_broadcastable() };
1355 let tx = CommitmentTransaction::new_with_auxiliary_htlc_data(commitment_number,
1362 &mut included_non_dust_htlcs,
1365 let mut htlcs_included = included_non_dust_htlcs;
1366 // The unwrap is safe, because all non-dust HTLCs have been assigned an output index
1367 htlcs_included.sort_unstable_by_key(|h| h.0.transaction_output_index.unwrap());
1368 htlcs_included.append(&mut included_dust_htlcs);
1370 // For the stats, trimmed-to-0 the value in msats accordingly
1371 value_to_self_msat = if (value_to_self_msat * 1000) < broadcaster_dust_limit_satoshis as i64 { 0 } else { value_to_self_msat };
1372 value_to_remote_msat = if (value_to_remote_msat * 1000) < broadcaster_dust_limit_satoshis as i64 { 0 } else { value_to_remote_msat };
1380 local_balance_msat: value_to_self_msat as u64,
1381 remote_balance_msat: value_to_remote_msat as u64,
1387 /// Creates a set of keys for build_commitment_transaction to generate a transaction which our
1388 /// counterparty will sign (ie DO NOT send signatures over a transaction created by this to
1389 /// our counterparty!)
1390 /// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
1391 /// TODO Some magic rust shit to compile-time check this?
1392 fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
1393 let per_commitment_point = self.holder_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
1394 let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
1395 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
1396 let counterparty_pubkeys = self.get_counterparty_pubkeys();
1398 TxCreationKeys::derive_new(&self.secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint)
1402 /// Creates a set of keys for build_commitment_transaction to generate a transaction which we
1403 /// will sign and send to our counterparty.
1404 /// If an Err is returned, it is a ChannelError::Close (for get_outbound_funding_created)
1405 fn build_remote_transaction_keys(&self) -> TxCreationKeys {
1406 //TODO: Ensure that the payment_key derived here ends up in the library users' wallet as we
1407 //may see payments to it!
1408 let revocation_basepoint = &self.get_holder_pubkeys().revocation_basepoint;
1409 let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
1410 let counterparty_pubkeys = self.get_counterparty_pubkeys();
1412 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)
1415 /// Gets the redeemscript for the funding transaction output (ie the funding transaction output
1416 /// pays to get_funding_redeemscript().to_v0_p2wsh()).
1417 /// Panics if called before accept_channel/InboundV1Channel::new
1418 pub fn get_funding_redeemscript(&self) -> Script {
1419 make_funding_redeemscript(&self.get_holder_pubkeys().funding_pubkey, self.counterparty_funding_pubkey())
1422 fn counterparty_funding_pubkey(&self) -> &PublicKey {
1423 &self.get_counterparty_pubkeys().funding_pubkey
1426 pub fn get_feerate_sat_per_1000_weight(&self) -> u32 {
1430 pub fn get_dust_buffer_feerate(&self, outbound_feerate_update: Option<u32>) -> u32 {
1431 // When calculating our exposure to dust HTLCs, we assume that the channel feerate
1432 // may, at any point, increase by at least 10 sat/vB (i.e 2530 sat/kWU) or 25%,
1433 // whichever is higher. This ensures that we aren't suddenly exposed to significantly
1434 // more dust balance if the feerate increases when we have several HTLCs pending
1435 // which are near the dust limit.
1436 let mut feerate_per_kw = self.feerate_per_kw;
1437 // If there's a pending update fee, use it to ensure we aren't under-estimating
1438 // potential feerate updates coming soon.
1439 if let Some((feerate, _)) = self.pending_update_fee {
1440 feerate_per_kw = cmp::max(feerate_per_kw, feerate);
1442 if let Some(feerate) = outbound_feerate_update {
1443 feerate_per_kw = cmp::max(feerate_per_kw, feerate);
1445 cmp::max(2530, feerate_per_kw * 1250 / 1000)
1448 /// Get forwarding information for the counterparty.
1449 pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
1450 self.counterparty_forwarding_info.clone()
1453 /// Returns a HTLCStats about inbound pending htlcs
1454 fn get_inbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
1456 let mut stats = HTLCStats {
1457 pending_htlcs: context.pending_inbound_htlcs.len() as u32,
1458 pending_htlcs_value_msat: 0,
1459 on_counterparty_tx_dust_exposure_msat: 0,
1460 on_holder_tx_dust_exposure_msat: 0,
1461 holding_cell_msat: 0,
1462 on_holder_tx_holding_cell_htlcs_count: 0,
1465 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1468 let dust_buffer_feerate = context.get_dust_buffer_feerate(outbound_feerate_update) as u64;
1469 (dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000,
1470 dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000)
1472 let counterparty_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.counterparty_dust_limit_satoshis;
1473 let holder_dust_limit_success_sat = htlc_success_dust_limit + context.holder_dust_limit_satoshis;
1474 for ref htlc in context.pending_inbound_htlcs.iter() {
1475 stats.pending_htlcs_value_msat += htlc.amount_msat;
1476 if htlc.amount_msat / 1000 < counterparty_dust_limit_timeout_sat {
1477 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
1479 if htlc.amount_msat / 1000 < holder_dust_limit_success_sat {
1480 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
1486 /// Returns a HTLCStats about pending outbound htlcs, *including* pending adds in our holding cell.
1487 fn get_outbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
1489 let mut stats = HTLCStats {
1490 pending_htlcs: context.pending_outbound_htlcs.len() as u32,
1491 pending_htlcs_value_msat: 0,
1492 on_counterparty_tx_dust_exposure_msat: 0,
1493 on_holder_tx_dust_exposure_msat: 0,
1494 holding_cell_msat: 0,
1495 on_holder_tx_holding_cell_htlcs_count: 0,
1498 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1501 let dust_buffer_feerate = context.get_dust_buffer_feerate(outbound_feerate_update) as u64;
1502 (dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000,
1503 dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000)
1505 let counterparty_dust_limit_success_sat = htlc_success_dust_limit + context.counterparty_dust_limit_satoshis;
1506 let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.holder_dust_limit_satoshis;
1507 for ref htlc in context.pending_outbound_htlcs.iter() {
1508 stats.pending_htlcs_value_msat += htlc.amount_msat;
1509 if htlc.amount_msat / 1000 < counterparty_dust_limit_success_sat {
1510 stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
1512 if htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat {
1513 stats.on_holder_tx_dust_exposure_msat += htlc.amount_msat;
1517 for update in context.holding_cell_htlc_updates.iter() {
1518 if let &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, .. } = update {
1519 stats.pending_htlcs += 1;
1520 stats.pending_htlcs_value_msat += amount_msat;
1521 stats.holding_cell_msat += amount_msat;
1522 if *amount_msat / 1000 < counterparty_dust_limit_success_sat {
1523 stats.on_counterparty_tx_dust_exposure_msat += amount_msat;
1525 if *amount_msat / 1000 < holder_dust_limit_timeout_sat {
1526 stats.on_holder_tx_dust_exposure_msat += amount_msat;
1528 stats.on_holder_tx_holding_cell_htlcs_count += 1;
1535 /// Get the available balances, see [`AvailableBalances`]'s fields for more info.
1536 /// Doesn't bother handling the
1537 /// if-we-removed-it-already-but-haven't-fully-resolved-they-can-still-send-an-inbound-HTLC
1538 /// corner case properly.
1539 pub fn get_available_balances(&self) -> AvailableBalances {
1540 let context = &self;
1541 // Note that we have to handle overflow due to the above case.
1542 let inbound_stats = context.get_inbound_pending_htlc_stats(None);
1543 let outbound_stats = context.get_outbound_pending_htlc_stats(None);
1545 let mut balance_msat = context.value_to_self_msat;
1546 for ref htlc in context.pending_inbound_htlcs.iter() {
1547 if let InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) = htlc.state {
1548 balance_msat += htlc.amount_msat;
1551 balance_msat -= outbound_stats.pending_htlcs_value_msat;
1553 let outbound_capacity_msat = context.value_to_self_msat
1554 .saturating_sub(outbound_stats.pending_htlcs_value_msat)
1556 context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000);
1558 let mut available_capacity_msat = outbound_capacity_msat;
1560 if context.is_outbound() {
1561 // We should mind channel commit tx fee when computing how much of the available capacity
1562 // can be used in the next htlc. Mirrors the logic in send_htlc.
1564 // The fee depends on whether the amount we will be sending is above dust or not,
1565 // and the answer will in turn change the amount itself — making it a circular
1567 // This complicates the computation around dust-values, up to the one-htlc-value.
1568 let mut real_dust_limit_timeout_sat = context.holder_dust_limit_satoshis;
1569 if !context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1570 real_dust_limit_timeout_sat += context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000;
1573 let htlc_above_dust = HTLCCandidate::new(real_dust_limit_timeout_sat * 1000, HTLCInitiator::LocalOffered);
1574 let max_reserved_commit_tx_fee_msat = FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE * context.next_local_commit_tx_fee_msat(htlc_above_dust, Some(()));
1575 let htlc_dust = HTLCCandidate::new(real_dust_limit_timeout_sat * 1000 - 1, HTLCInitiator::LocalOffered);
1576 let min_reserved_commit_tx_fee_msat = FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE * context.next_local_commit_tx_fee_msat(htlc_dust, Some(()));
1578 // We will first subtract the fee as if we were above-dust. Then, if the resulting
1579 // value ends up being below dust, we have this fee available again. In that case,
1580 // match the value to right-below-dust.
1581 let mut capacity_minus_commitment_fee_msat: i64 = (available_capacity_msat as i64) - (max_reserved_commit_tx_fee_msat as i64);
1582 if capacity_minus_commitment_fee_msat < (real_dust_limit_timeout_sat as i64) * 1000 {
1583 let one_htlc_difference_msat = max_reserved_commit_tx_fee_msat - min_reserved_commit_tx_fee_msat;
1584 debug_assert!(one_htlc_difference_msat != 0);
1585 capacity_minus_commitment_fee_msat += one_htlc_difference_msat as i64;
1586 capacity_minus_commitment_fee_msat = cmp::min(real_dust_limit_timeout_sat as i64 * 1000 - 1, capacity_minus_commitment_fee_msat);
1587 available_capacity_msat = cmp::max(0, cmp::min(capacity_minus_commitment_fee_msat, available_capacity_msat as i64)) as u64;
1589 available_capacity_msat = capacity_minus_commitment_fee_msat as u64;
1592 // If the channel is inbound (i.e. counterparty pays the fee), we need to make sure
1593 // sending a new HTLC won't reduce their balance below our reserve threshold.
1594 let mut real_dust_limit_success_sat = context.counterparty_dust_limit_satoshis;
1595 if !context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1596 real_dust_limit_success_sat += context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000;
1599 let htlc_above_dust = HTLCCandidate::new(real_dust_limit_success_sat * 1000, HTLCInitiator::LocalOffered);
1600 let max_reserved_commit_tx_fee_msat = context.next_remote_commit_tx_fee_msat(htlc_above_dust, None);
1602 let holder_selected_chan_reserve_msat = context.holder_selected_channel_reserve_satoshis * 1000;
1603 let remote_balance_msat = (context.channel_value_satoshis * 1000 - context.value_to_self_msat)
1604 .saturating_sub(inbound_stats.pending_htlcs_value_msat);
1606 if remote_balance_msat < max_reserved_commit_tx_fee_msat + holder_selected_chan_reserve_msat {
1607 // If another HTLC's fee would reduce the remote's balance below the reserve limit
1608 // we've selected for them, we can only send dust HTLCs.
1609 available_capacity_msat = cmp::min(available_capacity_msat, real_dust_limit_success_sat * 1000 - 1);
1613 let mut next_outbound_htlc_minimum_msat = context.counterparty_htlc_minimum_msat;
1615 // If we get close to our maximum dust exposure, we end up in a situation where we can send
1616 // between zero and the remaining dust exposure limit remaining OR above the dust limit.
1617 // Because we cannot express this as a simple min/max, we prefer to tell the user they can
1618 // send above the dust limit (as the router can always overpay to meet the dust limit).
1619 let mut remaining_msat_below_dust_exposure_limit = None;
1620 let mut dust_exposure_dust_limit_msat = 0;
1622 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1623 (context.counterparty_dust_limit_satoshis, context.holder_dust_limit_satoshis)
1625 let dust_buffer_feerate = context.get_dust_buffer_feerate(None) as u64;
1626 (context.counterparty_dust_limit_satoshis + dust_buffer_feerate * htlc_success_tx_weight(context.get_channel_type()) / 1000,
1627 context.holder_dust_limit_satoshis + dust_buffer_feerate * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
1629 let on_counterparty_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
1630 if on_counterparty_dust_htlc_exposure_msat as i64 + htlc_success_dust_limit as i64 * 1000 - 1 > context.get_max_dust_htlc_exposure_msat() as i64 {
1631 remaining_msat_below_dust_exposure_limit =
1632 Some(context.get_max_dust_htlc_exposure_msat().saturating_sub(on_counterparty_dust_htlc_exposure_msat));
1633 dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, htlc_success_dust_limit * 1000);
1636 let on_holder_dust_htlc_exposure_msat = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
1637 if on_holder_dust_htlc_exposure_msat as i64 + htlc_timeout_dust_limit as i64 * 1000 - 1 > context.get_max_dust_htlc_exposure_msat() as i64 {
1638 remaining_msat_below_dust_exposure_limit = Some(cmp::min(
1639 remaining_msat_below_dust_exposure_limit.unwrap_or(u64::max_value()),
1640 context.get_max_dust_htlc_exposure_msat().saturating_sub(on_holder_dust_htlc_exposure_msat)));
1641 dust_exposure_dust_limit_msat = cmp::max(dust_exposure_dust_limit_msat, htlc_timeout_dust_limit * 1000);
1644 if let Some(remaining_limit_msat) = remaining_msat_below_dust_exposure_limit {
1645 if available_capacity_msat < dust_exposure_dust_limit_msat {
1646 available_capacity_msat = cmp::min(available_capacity_msat, remaining_limit_msat);
1648 next_outbound_htlc_minimum_msat = cmp::max(next_outbound_htlc_minimum_msat, dust_exposure_dust_limit_msat);
1652 available_capacity_msat = cmp::min(available_capacity_msat,
1653 context.counterparty_max_htlc_value_in_flight_msat - outbound_stats.pending_htlcs_value_msat);
1655 if outbound_stats.pending_htlcs + 1 > context.counterparty_max_accepted_htlcs as u32 {
1656 available_capacity_msat = 0;
1660 inbound_capacity_msat: cmp::max(context.channel_value_satoshis as i64 * 1000
1661 - context.value_to_self_msat as i64
1662 - context.get_inbound_pending_htlc_stats(None).pending_htlcs_value_msat as i64
1663 - context.holder_selected_channel_reserve_satoshis as i64 * 1000,
1665 outbound_capacity_msat,
1666 next_outbound_htlc_limit_msat: available_capacity_msat,
1667 next_outbound_htlc_minimum_msat,
1672 pub fn get_holder_counterparty_selected_channel_reserve_satoshis(&self) -> (u64, Option<u64>) {
1673 let context = &self;
1674 (context.holder_selected_channel_reserve_satoshis, context.counterparty_selected_channel_reserve_satoshis)
1677 /// Get the commitment tx fee for the local's (i.e. our) next commitment transaction based on the
1678 /// number of pending HTLCs that are on track to be in our next commitment tx.
1680 /// Optionally includes the `HTLCCandidate` given by `htlc` and an additional non-dust HTLC if
1681 /// `fee_spike_buffer_htlc` is `Some`.
1683 /// The first extra HTLC is useful for determining whether we can accept a further HTLC, the
1684 /// second allows for creating a buffer to ensure a further HTLC can always be accepted/added.
1686 /// Dust HTLCs are excluded.
1687 fn next_local_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
1688 let context = &self;
1689 assert!(context.is_outbound());
1691 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1694 (context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000,
1695 context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
1697 let real_dust_limit_success_sat = htlc_success_dust_limit + context.holder_dust_limit_satoshis;
1698 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.holder_dust_limit_satoshis;
1700 let mut addl_htlcs = 0;
1701 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
1703 HTLCInitiator::LocalOffered => {
1704 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
1708 HTLCInitiator::RemoteOffered => {
1709 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
1715 let mut included_htlcs = 0;
1716 for ref htlc in context.pending_inbound_htlcs.iter() {
1717 if htlc.amount_msat / 1000 < real_dust_limit_success_sat {
1720 // We include LocalRemoved HTLCs here because we may still need to broadcast a commitment
1721 // transaction including this HTLC if it times out before they RAA.
1722 included_htlcs += 1;
1725 for ref htlc in context.pending_outbound_htlcs.iter() {
1726 if htlc.amount_msat / 1000 < real_dust_limit_timeout_sat {
1730 OutboundHTLCState::LocalAnnounced {..} => included_htlcs += 1,
1731 OutboundHTLCState::Committed => included_htlcs += 1,
1732 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
1733 // We don't include AwaitingRemoteRevokeToRemove HTLCs because our next commitment
1734 // transaction won't be generated until they send us their next RAA, which will mean
1735 // dropping any HTLCs in this state.
1740 for htlc in context.holding_cell_htlc_updates.iter() {
1742 &HTLCUpdateAwaitingACK::AddHTLC { amount_msat, .. } => {
1743 if amount_msat / 1000 < real_dust_limit_timeout_sat {
1748 _ => {}, // Don't include claims/fails that are awaiting ack, because once we get the
1749 // ack we're guaranteed to never include them in commitment txs anymore.
1753 let num_htlcs = included_htlcs + addl_htlcs;
1754 let res = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs, &context.channel_type);
1755 #[cfg(any(test, fuzzing))]
1758 if fee_spike_buffer_htlc.is_some() {
1759 fee = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs - 1, &context.channel_type);
1761 let total_pending_htlcs = context.pending_inbound_htlcs.len() + context.pending_outbound_htlcs.len()
1762 + context.holding_cell_htlc_updates.len();
1763 let commitment_tx_info = CommitmentTxInfoCached {
1765 total_pending_htlcs,
1766 next_holder_htlc_id: match htlc.origin {
1767 HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
1768 HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
1770 next_counterparty_htlc_id: match htlc.origin {
1771 HTLCInitiator::LocalOffered => context.next_counterparty_htlc_id,
1772 HTLCInitiator::RemoteOffered => context.next_counterparty_htlc_id + 1,
1774 feerate: context.feerate_per_kw,
1776 *context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
1781 /// Get the commitment tx fee for the remote's next commitment transaction based on the number of
1782 /// pending HTLCs that are on track to be in their next commitment tx
1784 /// Optionally includes the `HTLCCandidate` given by `htlc` and an additional non-dust HTLC if
1785 /// `fee_spike_buffer_htlc` is `Some`.
1787 /// The first extra HTLC is useful for determining whether we can accept a further HTLC, the
1788 /// second allows for creating a buffer to ensure a further HTLC can always be accepted/added.
1790 /// Dust HTLCs are excluded.
1791 fn next_remote_commit_tx_fee_msat(&self, htlc: HTLCCandidate, fee_spike_buffer_htlc: Option<()>) -> u64 {
1792 let context = &self;
1793 assert!(!context.is_outbound());
1795 let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
1798 (context.feerate_per_kw as u64 * htlc_success_tx_weight(context.get_channel_type()) / 1000,
1799 context.feerate_per_kw as u64 * htlc_timeout_tx_weight(context.get_channel_type()) / 1000)
1801 let real_dust_limit_success_sat = htlc_success_dust_limit + context.counterparty_dust_limit_satoshis;
1802 let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + context.counterparty_dust_limit_satoshis;
1804 let mut addl_htlcs = 0;
1805 if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
1807 HTLCInitiator::LocalOffered => {
1808 if htlc.amount_msat / 1000 >= real_dust_limit_success_sat {
1812 HTLCInitiator::RemoteOffered => {
1813 if htlc.amount_msat / 1000 >= real_dust_limit_timeout_sat {
1819 // When calculating the set of HTLCs which will be included in their next commitment_signed, all
1820 // non-dust inbound HTLCs are included (as all states imply it will be included) and only
1821 // committed outbound HTLCs, see below.
1822 let mut included_htlcs = 0;
1823 for ref htlc in context.pending_inbound_htlcs.iter() {
1824 if htlc.amount_msat / 1000 <= real_dust_limit_timeout_sat {
1827 included_htlcs += 1;
1830 for ref htlc in context.pending_outbound_htlcs.iter() {
1831 if htlc.amount_msat / 1000 <= real_dust_limit_success_sat {
1834 // We only include outbound HTLCs if it will not be included in their next commitment_signed,
1835 // i.e. if they've responded to us with an RAA after announcement.
1837 OutboundHTLCState::Committed => included_htlcs += 1,
1838 OutboundHTLCState::RemoteRemoved {..} => included_htlcs += 1,
1839 OutboundHTLCState::LocalAnnounced { .. } => included_htlcs += 1,
1844 let num_htlcs = included_htlcs + addl_htlcs;
1845 let res = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs, &context.channel_type);
1846 #[cfg(any(test, fuzzing))]
1849 if fee_spike_buffer_htlc.is_some() {
1850 fee = commit_tx_fee_msat(context.feerate_per_kw, num_htlcs - 1, &context.channel_type);
1852 let total_pending_htlcs = context.pending_inbound_htlcs.len() + context.pending_outbound_htlcs.len();
1853 let commitment_tx_info = CommitmentTxInfoCached {
1855 total_pending_htlcs,
1856 next_holder_htlc_id: match htlc.origin {
1857 HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
1858 HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
1860 next_counterparty_htlc_id: match htlc.origin {
1861 HTLCInitiator::LocalOffered => context.next_counterparty_htlc_id,
1862 HTLCInitiator::RemoteOffered => context.next_counterparty_htlc_id + 1,
1864 feerate: context.feerate_per_kw,
1866 *context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
1871 /// Returns transaction if there is pending funding transaction that is yet to broadcast
1872 pub fn unbroadcasted_funding(&self) -> Option<Transaction> {
1873 if self.channel_state & (ChannelState::FundingCreated as u32) != 0 {
1874 self.funding_transaction.clone()
1880 /// Gets the latest commitment transaction and any dependent transactions for relay (forcing
1881 /// shutdown of this channel - no more calls into this Channel may be made afterwards except
1882 /// those explicitly stated to be allowed after shutdown completes, eg some simple getters).
1883 /// Also returns the list of payment_hashes for channels which we can safely fail backwards
1884 /// immediately (others we will have to allow to time out).
1885 pub fn force_shutdown(&mut self, should_broadcast: bool) -> ShutdownResult {
1886 // Note that we MUST only generate a monitor update that indicates force-closure - we're
1887 // called during initialization prior to the chain_monitor in the encompassing ChannelManager
1888 // being fully configured in some cases. Thus, its likely any monitor events we generate will
1889 // be delayed in being processed! See the docs for `ChannelManagerReadArgs` for more.
1890 assert!(self.channel_state != ChannelState::ShutdownComplete as u32);
1892 // We go ahead and "free" any holding cell HTLCs or HTLCs we haven't yet committed to and
1893 // return them to fail the payment.
1894 let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
1895 let counterparty_node_id = self.get_counterparty_node_id();
1896 for htlc_update in self.holding_cell_htlc_updates.drain(..) {
1898 HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. } => {
1899 dropped_outbound_htlcs.push((source, payment_hash, counterparty_node_id, self.channel_id));
1904 let monitor_update = if let Some(funding_txo) = self.get_funding_txo() {
1905 // If we haven't yet exchanged funding signatures (ie channel_state < FundingSent),
1906 // returning a channel monitor update here would imply a channel monitor update before
1907 // we even registered the channel monitor to begin with, which is invalid.
1908 // Thus, if we aren't actually at a point where we could conceivably broadcast the
1909 // funding transaction, don't return a funding txo (which prevents providing the
1910 // monitor update to the user, even if we return one).
1911 // See test_duplicate_chan_id and test_pre_lockin_no_chan_closed_update for more.
1912 if self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::ChannelReady as u32 | ChannelState::ShutdownComplete as u32) != 0 {
1913 self.latest_monitor_update_id = CLOSED_CHANNEL_UPDATE_ID;
1914 Some((self.get_counterparty_node_id(), funding_txo, ChannelMonitorUpdate {
1915 update_id: self.latest_monitor_update_id,
1916 updates: vec![ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast }],
1921 self.channel_state = ChannelState::ShutdownComplete as u32;
1922 self.update_time_counter += 1;
1923 (monitor_update, dropped_outbound_htlcs)
1927 // Internal utility functions for channels
1929 /// Returns the value to use for `holder_max_htlc_value_in_flight_msat` as a percentage of the
1930 /// `channel_value_satoshis` in msat, set through
1931 /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]
1933 /// The effective percentage is lower bounded by 1% and upper bounded by 100%.
1935 /// [`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`]: crate::util::config::ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel
1936 fn get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis: u64, config: &ChannelHandshakeConfig) -> u64 {
1937 let configured_percent = if config.max_inbound_htlc_value_in_flight_percent_of_channel < 1 {
1939 } else if config.max_inbound_htlc_value_in_flight_percent_of_channel > 100 {
1942 config.max_inbound_htlc_value_in_flight_percent_of_channel as u64
1944 channel_value_satoshis * 10 * configured_percent
1947 /// Returns a minimum channel reserve value the remote needs to maintain,
1948 /// required by us according to the configured or default
1949 /// [`ChannelHandshakeConfig::their_channel_reserve_proportional_millionths`]
1951 /// Guaranteed to return a value no larger than channel_value_satoshis
1953 /// This is used both for outbound and inbound channels and has lower bound
1954 /// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`.
1955 pub(crate) fn get_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64, config: &UserConfig) -> u64 {
1956 let calculated_reserve = channel_value_satoshis.saturating_mul(config.channel_handshake_config.their_channel_reserve_proportional_millionths as u64) / 1_000_000;
1957 cmp::min(channel_value_satoshis, cmp::max(calculated_reserve, MIN_THEIR_CHAN_RESERVE_SATOSHIS))
1960 /// This is for legacy reasons, present for forward-compatibility.
1961 /// LDK versions older than 0.0.104 don't know how read/handle values other than default
1962 /// from storage. Hence, we use this function to not persist default values of
1963 /// `holder_selected_channel_reserve_satoshis` for channels into storage.
1964 pub(crate) fn get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis: u64) -> u64 {
1965 let (q, _) = channel_value_satoshis.overflowing_div(100);
1966 cmp::min(channel_value_satoshis, cmp::max(q, 1000))
1969 // Get the fee cost in SATS of a commitment tx with a given number of HTLC outputs.
1970 // Note that num_htlcs should not include dust HTLCs.
1972 fn commit_tx_fee_sat(feerate_per_kw: u32, num_htlcs: usize, channel_type_features: &ChannelTypeFeatures) -> u64 {
1973 feerate_per_kw as u64 * (commitment_tx_base_weight(channel_type_features) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000
1976 // Get the fee cost in MSATS of a commitment tx with a given number of HTLC outputs.
1977 // Note that num_htlcs should not include dust HTLCs.
1978 fn commit_tx_fee_msat(feerate_per_kw: u32, num_htlcs: usize, channel_type_features: &ChannelTypeFeatures) -> u64 {
1979 // Note that we need to divide before multiplying to round properly,
1980 // since the lowest denomination of bitcoin on-chain is the satoshi.
1981 (commitment_tx_base_weight(channel_type_features) + num_htlcs as u64 * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate_per_kw as u64 / 1000 * 1000
1984 // TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
1985 // has been completed, and then turn into a Channel to get compiler-time enforcement of things like
1986 // calling channel_id() before we're set up or things like get_outbound_funding_signed on an
1989 // Holder designates channel data owned for the benefit of the user client.
1990 // Counterparty designates channel data owned by the another channel participant entity.
1991 pub(super) struct Channel<Signer: ChannelSigner> {
1992 pub context: ChannelContext<Signer>,
1995 #[cfg(any(test, fuzzing))]
1996 struct CommitmentTxInfoCached {
1998 total_pending_htlcs: usize,
1999 next_holder_htlc_id: u64,
2000 next_counterparty_htlc_id: u64,
2004 impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
2005 fn check_remote_fee<F: Deref, L: Deref>(fee_estimator: &LowerBoundedFeeEstimator<F>,
2006 feerate_per_kw: u32, cur_feerate_per_kw: Option<u32>, logger: &L)
2007 -> Result<(), ChannelError> where F::Target: FeeEstimator, L::Target: Logger,
2009 // We only bound the fee updates on the upper side to prevent completely absurd feerates,
2010 // always accepting up to 25 sat/vByte or 10x our fee estimator's "High Priority" fee.
2011 // We generally don't care too much if they set the feerate to something very high, but it
2012 // could result in the channel being useless due to everything being dust.
2013 let upper_limit = cmp::max(250 * 25,
2014 fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::HighPriority) as u64 * 10);
2015 if feerate_per_kw as u64 > upper_limit {
2016 return Err(ChannelError::Close(format!("Peer's feerate much too high. Actual: {}. Our expected upper limit: {}", feerate_per_kw, upper_limit)));
2018 let lower_limit = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Background);
2019 // Some fee estimators round up to the next full sat/vbyte (ie 250 sats per kw), causing
2020 // occasional issues with feerate disagreements between an initiator that wants a feerate
2021 // of 1.1 sat/vbyte and a receiver that wants 1.1 rounded up to 2. Thus, we always add 250
2022 // sat/kw before the comparison here.
2023 if feerate_per_kw + 250 < lower_limit {
2024 if let Some(cur_feerate) = cur_feerate_per_kw {
2025 if feerate_per_kw > cur_feerate {
2027 "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.",
2028 cur_feerate, feerate_per_kw);
2032 return Err(ChannelError::Close(format!("Peer's feerate much too low. Actual: {}. Our expected lower limit: {} (- 250)", feerate_per_kw, lower_limit)));
2038 fn get_closing_scriptpubkey(&self) -> Script {
2039 // The shutdown scriptpubkey is set on channel opening when option_upfront_shutdown_script
2040 // is signaled. Otherwise, it is set when sending a shutdown message. Calling this method
2041 // outside of those situations will fail.
2042 self.context.shutdown_scriptpubkey.clone().unwrap().into_inner()
2046 fn get_closing_transaction_weight(&self, a_scriptpubkey: Option<&Script>, b_scriptpubkey: Option<&Script>) -> u64 {
2051 1 + // script length (0)
2055 )*4 + // * 4 for non-witness parts
2056 2 + // witness marker and flag
2057 1 + // witness element count
2058 4 + // 4 element lengths (2 sigs, multisig dummy, and witness script)
2059 self.context.get_funding_redeemscript().len() as u64 + // funding witness script
2060 2*(1 + 71); // two signatures + sighash type flags
2061 if let Some(spk) = a_scriptpubkey {
2062 ret += ((8+1) + // output values and script length
2063 spk.len() as u64) * 4; // scriptpubkey and witness multiplier
2065 if let Some(spk) = b_scriptpubkey {
2066 ret += ((8+1) + // output values and script length
2067 spk.len() as u64) * 4; // scriptpubkey and witness multiplier
2073 fn build_closing_transaction(&self, proposed_total_fee_satoshis: u64, skip_remote_output: bool) -> (ClosingTransaction, u64) {
2074 assert!(self.context.pending_inbound_htlcs.is_empty());
2075 assert!(self.context.pending_outbound_htlcs.is_empty());
2076 assert!(self.context.pending_update_fee.is_none());
2078 let mut total_fee_satoshis = proposed_total_fee_satoshis;
2079 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 };
2080 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 };
2082 if value_to_holder < 0 {
2083 assert!(self.context.is_outbound());
2084 total_fee_satoshis += (-value_to_holder) as u64;
2085 } else if value_to_counterparty < 0 {
2086 assert!(!self.context.is_outbound());
2087 total_fee_satoshis += (-value_to_counterparty) as u64;
2090 if skip_remote_output || value_to_counterparty as u64 <= self.context.holder_dust_limit_satoshis {
2091 value_to_counterparty = 0;
2094 if value_to_holder as u64 <= self.context.holder_dust_limit_satoshis {
2095 value_to_holder = 0;
2098 assert!(self.context.shutdown_scriptpubkey.is_some());
2099 let holder_shutdown_script = self.get_closing_scriptpubkey();
2100 let counterparty_shutdown_script = self.context.counterparty_shutdown_scriptpubkey.clone().unwrap();
2101 let funding_outpoint = self.funding_outpoint().into_bitcoin_outpoint();
2103 let closing_transaction = ClosingTransaction::new(value_to_holder as u64, value_to_counterparty as u64, holder_shutdown_script, counterparty_shutdown_script, funding_outpoint);
2104 (closing_transaction, total_fee_satoshis)
2107 fn funding_outpoint(&self) -> OutPoint {
2108 self.context.channel_transaction_parameters.funding_outpoint.unwrap()
2111 /// Claims an HTLC while we're disconnected from a peer, dropping the [`ChannelMonitorUpdate`]
2114 /// The [`ChannelMonitor`] for this channel MUST be updated out-of-band with the preimage
2115 /// provided (i.e. without calling [`crate::chain::Watch::update_channel`]).
2117 /// The HTLC claim will end up in the holding cell (because the caller must ensure the peer is
2119 pub fn claim_htlc_while_disconnected_dropping_mon_update<L: Deref>
2120 (&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L)
2121 where L::Target: Logger {
2122 // Assert that we'll add the HTLC claim to the holding cell in `get_update_fulfill_htlc`
2123 // (see equivalent if condition there).
2124 assert!(self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0);
2125 let mon_update_id = self.context.latest_monitor_update_id; // Forget the ChannelMonitor update
2126 let fulfill_resp = self.get_update_fulfill_htlc(htlc_id_arg, payment_preimage_arg, logger);
2127 self.context.latest_monitor_update_id = mon_update_id;
2128 if let UpdateFulfillFetch::NewClaim { msg, .. } = fulfill_resp {
2129 assert!(msg.is_none()); // The HTLC must have ended up in the holding cell.
2133 fn get_update_fulfill_htlc<L: Deref>(&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L) -> UpdateFulfillFetch where L::Target: Logger {
2134 // Either ChannelReady got set (which means it won't be unset) or there is no way any
2135 // caller thought we could have something claimed (cause we wouldn't have accepted in an
2136 // incoming HTLC anyway). If we got to ShutdownComplete, callers aren't allowed to call us,
2138 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2139 panic!("Was asked to fulfill an HTLC when channel was not in an operational state");
2141 assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
2143 let payment_hash_calc = PaymentHash(Sha256::hash(&payment_preimage_arg.0[..]).into_inner());
2145 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
2146 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
2147 // these, but for now we just have to treat them as normal.
2149 let mut pending_idx = core::usize::MAX;
2150 let mut htlc_value_msat = 0;
2151 for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
2152 if htlc.htlc_id == htlc_id_arg {
2153 assert_eq!(htlc.payment_hash, payment_hash_calc);
2155 InboundHTLCState::Committed => {},
2156 InboundHTLCState::LocalRemoved(ref reason) => {
2157 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
2159 log_warn!(logger, "Have preimage and want to fulfill HTLC with payment hash {} we already failed against channel {}", log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id()));
2160 debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
2162 return UpdateFulfillFetch::DuplicateClaim {};
2165 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
2166 // Don't return in release mode here so that we can update channel_monitor
2170 htlc_value_msat = htlc.amount_msat;
2174 if pending_idx == core::usize::MAX {
2175 #[cfg(any(test, fuzzing))]
2176 // If we failed to find an HTLC to fulfill, make sure it was previously fulfilled and
2177 // this is simply a duplicate claim, not previously failed and we lost funds.
2178 debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2179 return UpdateFulfillFetch::DuplicateClaim {};
2182 // Now update local state:
2184 // We have to put the payment_preimage in the channel_monitor right away here to ensure we
2185 // can claim it even if the channel hits the chain before we see their next commitment.
2186 self.context.latest_monitor_update_id += 1;
2187 let monitor_update = ChannelMonitorUpdate {
2188 update_id: self.context.latest_monitor_update_id,
2189 updates: vec![ChannelMonitorUpdateStep::PaymentPreimage {
2190 payment_preimage: payment_preimage_arg.clone(),
2194 if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
2195 // Note that this condition is the same as the assertion in
2196 // `claim_htlc_while_disconnected_dropping_mon_update` and must match exactly -
2197 // `claim_htlc_while_disconnected_dropping_mon_update` would not work correctly if we
2198 // do not not get into this branch.
2199 for pending_update in self.context.holding_cell_htlc_updates.iter() {
2200 match pending_update {
2201 &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
2202 if htlc_id_arg == htlc_id {
2203 // Make sure we don't leave latest_monitor_update_id incremented here:
2204 self.context.latest_monitor_update_id -= 1;
2205 #[cfg(any(test, fuzzing))]
2206 debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2207 return UpdateFulfillFetch::DuplicateClaim {};
2210 &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
2211 if htlc_id_arg == htlc_id {
2212 log_warn!(logger, "Have preimage and want to fulfill HTLC with pending failure against channel {}", log_bytes!(self.context.channel_id()));
2213 // TODO: We may actually be able to switch to a fulfill here, though its
2214 // rare enough it may not be worth the complexity burden.
2215 debug_assert!(false, "Tried to fulfill an HTLC that was already failed");
2216 return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
2222 log_trace!(logger, "Adding HTLC claim to holding_cell in channel {}! Current state: {}", log_bytes!(self.context.channel_id()), self.context.channel_state);
2223 self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
2224 payment_preimage: payment_preimage_arg, htlc_id: htlc_id_arg,
2226 #[cfg(any(test, fuzzing))]
2227 self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
2228 return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
2230 #[cfg(any(test, fuzzing))]
2231 self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
2234 let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
2235 if let InboundHTLCState::Committed = htlc.state {
2237 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
2238 return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
2240 log_trace!(logger, "Upgrading HTLC {} to LocalRemoved with a Fulfill in channel {}!", log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
2241 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(payment_preimage_arg.clone()));
2244 UpdateFulfillFetch::NewClaim {
2247 msg: Some(msgs::UpdateFulfillHTLC {
2248 channel_id: self.context.channel_id(),
2249 htlc_id: htlc_id_arg,
2250 payment_preimage: payment_preimage_arg,
2255 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 {
2256 let release_cs_monitor = self.context.blocked_monitor_updates.is_empty();
2257 match self.get_update_fulfill_htlc(htlc_id, payment_preimage, logger) {
2258 UpdateFulfillFetch::NewClaim { mut monitor_update, htlc_value_msat, msg } => {
2259 // Even if we aren't supposed to let new monitor updates with commitment state
2260 // updates run, we still need to push the preimage ChannelMonitorUpdateStep no
2261 // matter what. Sadly, to push a new monitor update which flies before others
2262 // already queued, we have to insert it into the pending queue and update the
2263 // update_ids of all the following monitors.
2264 if release_cs_monitor && msg.is_some() {
2265 let mut additional_update = self.build_commitment_no_status_check(logger);
2266 // build_commitment_no_status_check may bump latest_monitor_id but we want them
2267 // to be strictly increasing by one, so decrement it here.
2268 self.context.latest_monitor_update_id = monitor_update.update_id;
2269 monitor_update.updates.append(&mut additional_update.updates);
2271 let new_mon_id = self.context.blocked_monitor_updates.get(0)
2272 .map(|upd| upd.update.update_id).unwrap_or(monitor_update.update_id);
2273 monitor_update.update_id = new_mon_id;
2274 for held_update in self.context.blocked_monitor_updates.iter_mut() {
2275 held_update.update.update_id += 1;
2278 debug_assert!(false, "If there is a pending blocked monitor we should have MonitorUpdateInProgress set");
2279 let update = self.build_commitment_no_status_check(logger);
2280 self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
2286 self.monitor_updating_paused(false, msg.is_some(), false, Vec::new(), Vec::new(), Vec::new());
2287 UpdateFulfillCommitFetch::NewClaim { monitor_update, htlc_value_msat, }
2289 UpdateFulfillFetch::DuplicateClaim {} => UpdateFulfillCommitFetch::DuplicateClaim {},
2293 /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
2294 /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
2295 /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
2296 /// before we fail backwards.
2298 /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
2299 /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
2300 /// [`ChannelError::Ignore`].
2301 pub fn queue_fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, logger: &L)
2302 -> Result<(), ChannelError> where L::Target: Logger {
2303 self.fail_htlc(htlc_id_arg, err_packet, true, logger)
2304 .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
2307 /// We can only have one resolution per HTLC. In some cases around reconnect, we may fulfill
2308 /// an HTLC more than once or fulfill once and then attempt to fail after reconnect. We cannot,
2309 /// however, fail more than once as we wait for an upstream failure to be irrevocably committed
2310 /// before we fail backwards.
2312 /// If we do fail twice, we `debug_assert!(false)` and return `Ok(None)`. Thus, this will always
2313 /// return `Ok(_)` if preconditions are met. In any case, `Err`s will only be
2314 /// [`ChannelError::Ignore`].
2315 fn fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, mut force_holding_cell: bool, logger: &L)
2316 -> Result<Option<msgs::UpdateFailHTLC>, ChannelError> where L::Target: Logger {
2317 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2318 panic!("Was asked to fail an HTLC when channel was not in an operational state");
2320 assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
2322 // ChannelManager may generate duplicate claims/fails due to HTLC update events from
2323 // on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
2324 // these, but for now we just have to treat them as normal.
2326 let mut pending_idx = core::usize::MAX;
2327 for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
2328 if htlc.htlc_id == htlc_id_arg {
2330 InboundHTLCState::Committed => {},
2331 InboundHTLCState::LocalRemoved(ref reason) => {
2332 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
2334 debug_assert!(false, "Tried to fail an HTLC that was already failed");
2339 debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
2340 return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc.htlc_id)));
2346 if pending_idx == core::usize::MAX {
2347 #[cfg(any(test, fuzzing))]
2348 // If we failed to find an HTLC to fail, make sure it was previously fulfilled and this
2349 // is simply a duplicate fail, not previously failed and we failed-back too early.
2350 debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2354 if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
2355 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!");
2356 force_holding_cell = true;
2359 // Now update local state:
2360 if force_holding_cell {
2361 for pending_update in self.context.holding_cell_htlc_updates.iter() {
2362 match pending_update {
2363 &HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
2364 if htlc_id_arg == htlc_id {
2365 #[cfg(any(test, fuzzing))]
2366 debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
2370 &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
2371 if htlc_id_arg == htlc_id {
2372 debug_assert!(false, "Tried to fail an HTLC that was already failed");
2373 return Err(ChannelError::Ignore("Unable to find a pending HTLC which matched the given HTLC ID".to_owned()));
2379 log_trace!(logger, "Placing failure for HTLC ID {} in holding cell in channel {}.", htlc_id_arg, log_bytes!(self.context.channel_id()));
2380 self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::FailHTLC {
2381 htlc_id: htlc_id_arg,
2387 log_trace!(logger, "Failing HTLC ID {} back with a update_fail_htlc message in channel {}.", htlc_id_arg, log_bytes!(self.context.channel_id()));
2389 let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
2390 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(err_packet.clone()));
2393 Ok(Some(msgs::UpdateFailHTLC {
2394 channel_id: self.context.channel_id(),
2395 htlc_id: htlc_id_arg,
2400 // Message handlers:
2402 /// Handles a funding_signed message from the remote end.
2403 /// If this call is successful, broadcast the funding transaction (and not before!)
2404 pub fn funding_signed<SP: Deref, L: Deref>(
2405 &mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
2406 ) -> Result<ChannelMonitor<Signer>, ChannelError>
2408 SP::Target: SignerProvider<Signer = Signer>,
2411 if !self.context.is_outbound() {
2412 return Err(ChannelError::Close("Received funding_signed for an inbound channel?".to_owned()));
2414 if self.context.channel_state & !(ChannelState::MonitorUpdateInProgress as u32) != ChannelState::FundingCreated as u32 {
2415 return Err(ChannelError::Close("Received funding_signed in strange state!".to_owned()));
2417 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
2418 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
2419 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
2420 panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
2423 let funding_script = self.context.get_funding_redeemscript();
2425 let counterparty_keys = self.context.build_remote_transaction_keys();
2426 let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
2427 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
2428 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
2430 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
2431 log_bytes!(self.context.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
2433 let holder_signer = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
2434 let initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &holder_signer, true, false, logger).tx;
2436 let trusted_tx = initial_commitment_tx.trust();
2437 let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
2438 let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
2439 // They sign our commitment transaction, allowing us to broadcast the tx if we wish.
2440 if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.get_counterparty_pubkeys().funding_pubkey) {
2441 return Err(ChannelError::Close("Invalid funding_signed signature from peer".to_owned()));
2445 let holder_commitment_tx = HolderCommitmentTransaction::new(
2446 initial_commitment_tx,
2449 &self.context.get_holder_pubkeys().funding_pubkey,
2450 self.context.counterparty_funding_pubkey()
2453 self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
2454 .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
2457 let funding_redeemscript = self.context.get_funding_redeemscript();
2458 let funding_txo = self.context.get_funding_txo().unwrap();
2459 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
2460 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());
2461 let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
2462 let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
2463 monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
2464 let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
2465 shutdown_script, self.context.get_holder_selected_contest_delay(),
2466 &self.context.destination_script, (funding_txo, funding_txo_script),
2467 &self.context.channel_transaction_parameters,
2468 funding_redeemscript.clone(), self.context.channel_value_satoshis,
2470 holder_commitment_tx, best_block, self.context.counterparty_node_id);
2472 channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_bitcoin_tx.txid, Vec::new(), self.context.cur_counterparty_commitment_transaction_number, self.context.counterparty_cur_commitment_point.unwrap(), logger);
2474 assert_eq!(self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32), 0); // We have no had any monitor(s) yet to fail update!
2475 self.context.channel_state = ChannelState::FundingSent as u32;
2476 self.context.cur_holder_commitment_transaction_number -= 1;
2477 self.context.cur_counterparty_commitment_transaction_number -= 1;
2479 log_info!(logger, "Received funding_signed from peer for channel {}", log_bytes!(self.context.channel_id()));
2481 let need_channel_ready = self.check_get_channel_ready(0).is_some();
2482 self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
2486 /// Handles a channel_ready message from our peer. If we've already sent our channel_ready
2487 /// and the channel is now usable (and public), this may generate an announcement_signatures to
2489 pub fn channel_ready<NS: Deref, L: Deref>(
2490 &mut self, msg: &msgs::ChannelReady, node_signer: &NS, genesis_block_hash: BlockHash,
2491 user_config: &UserConfig, best_block: &BestBlock, logger: &L
2492 ) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError>
2494 NS::Target: NodeSigner,
2497 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2498 self.context.workaround_lnd_bug_4006 = Some(msg.clone());
2499 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()));
2502 if let Some(scid_alias) = msg.short_channel_id_alias {
2503 if Some(scid_alias) != self.context.short_channel_id {
2504 // The scid alias provided can be used to route payments *from* our counterparty,
2505 // i.e. can be used for inbound payments and provided in invoices, but is not used
2506 // when routing outbound payments.
2507 self.context.latest_inbound_scid_alias = Some(scid_alias);
2511 let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
2513 if non_shutdown_state == ChannelState::FundingSent as u32 {
2514 self.context.channel_state |= ChannelState::TheirChannelReady as u32;
2515 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
2516 self.context.channel_state = ChannelState::ChannelReady as u32 | (self.context.channel_state & MULTI_STATE_FLAGS);
2517 self.context.update_time_counter += 1;
2518 } else if self.context.channel_state & (ChannelState::ChannelReady as u32) != 0 ||
2519 // If we reconnected before sending our `channel_ready` they may still resend theirs:
2520 (self.context.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) ==
2521 (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32))
2523 // They probably disconnected/reconnected and re-sent the channel_ready, which is
2524 // required, or they're sending a fresh SCID alias.
2525 let expected_point =
2526 if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
2527 // If they haven't ever sent an updated point, the point they send should match
2529 self.context.counterparty_cur_commitment_point
2530 } else if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
2531 // If we've advanced the commitment number once, the second commitment point is
2532 // at `counterparty_prev_commitment_point`, which is not yet revoked.
2533 debug_assert!(self.context.counterparty_prev_commitment_point.is_some());
2534 self.context.counterparty_prev_commitment_point
2536 // If they have sent updated points, channel_ready is always supposed to match
2537 // their "first" point, which we re-derive here.
2538 Some(PublicKey::from_secret_key(&self.context.secp_ctx, &SecretKey::from_slice(
2539 &self.context.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
2540 ).expect("We already advanced, so previous secret keys should have been validated already")))
2542 if expected_point != Some(msg.next_per_commitment_point) {
2543 return Err(ChannelError::Close("Peer sent a reconnect channel_ready with a different point".to_owned()));
2547 return Err(ChannelError::Close("Peer sent a channel_ready at a strange time".to_owned()));
2550 self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
2551 self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
2553 log_info!(logger, "Received channel_ready from peer for channel {}", log_bytes!(self.context.channel_id()));
2555 Ok(self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block.height(), logger))
2558 pub fn update_add_htlc<F, L: Deref>(&mut self, msg: &msgs::UpdateAddHTLC, mut pending_forward_status: PendingHTLCStatus, create_pending_htlc_status: F, logger: &L) -> Result<(), ChannelError>
2559 where F: for<'a> Fn(&'a Self, PendingHTLCStatus, u16) -> PendingHTLCStatus, L::Target: Logger {
2560 // We can't accept HTLCs sent after we've sent a shutdown.
2561 let local_sent_shutdown = (self.context.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::LocalShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
2562 if local_sent_shutdown {
2563 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x4000|8);
2565 // If the remote has sent a shutdown prior to adding this HTLC, then they are in violation of the spec.
2566 let remote_sent_shutdown = (self.context.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::RemoteShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
2567 if remote_sent_shutdown {
2568 return Err(ChannelError::Close("Got add HTLC message when channel was not in an operational state".to_owned()));
2570 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2571 return Err(ChannelError::Close("Peer sent update_add_htlc when we needed a channel_reestablish".to_owned()));
2573 if msg.amount_msat > self.context.channel_value_satoshis * 1000 {
2574 return Err(ChannelError::Close("Remote side tried to send more than the total value of the channel".to_owned()));
2576 if msg.amount_msat == 0 {
2577 return Err(ChannelError::Close("Remote side tried to send a 0-msat HTLC".to_owned()));
2579 if msg.amount_msat < self.context.holder_htlc_minimum_msat {
2580 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)));
2583 let inbound_stats = self.context.get_inbound_pending_htlc_stats(None);
2584 let outbound_stats = self.context.get_outbound_pending_htlc_stats(None);
2585 if inbound_stats.pending_htlcs + 1 > self.context.holder_max_accepted_htlcs as u32 {
2586 return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", self.context.holder_max_accepted_htlcs)));
2588 if inbound_stats.pending_htlcs_value_msat + msg.amount_msat > self.context.holder_max_htlc_value_in_flight_msat {
2589 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)));
2591 // Check holder_selected_channel_reserve_satoshis (we're getting paid, so they have to at least meet
2592 // the reserve_satoshis we told them to always have as direct payment so that they lose
2593 // something if we punish them for broadcasting an old state).
2594 // Note that we don't really care about having a small/no to_remote output in our local
2595 // commitment transactions, as the purpose of the channel reserve is to ensure we can
2596 // punish *them* if they misbehave, so we discount any outbound HTLCs which will not be
2597 // present in the next commitment transaction we send them (at least for fulfilled ones,
2598 // failed ones won't modify value_to_self).
2599 // Note that we will send HTLCs which another instance of rust-lightning would think
2600 // violate the reserve value if we do not do this (as we forget inbound HTLCs from the
2601 // Channel state once they will not be present in the next received commitment
2603 let mut removed_outbound_total_msat = 0;
2604 for ref htlc in self.context.pending_outbound_htlcs.iter() {
2605 if let OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_)) = htlc.state {
2606 removed_outbound_total_msat += htlc.amount_msat;
2607 } else if let OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) = htlc.state {
2608 removed_outbound_total_msat += htlc.amount_msat;
2612 let (htlc_timeout_dust_limit, htlc_success_dust_limit) = if self.context.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
2615 let dust_buffer_feerate = self.context.get_dust_buffer_feerate(None) as u64;
2616 (dust_buffer_feerate * htlc_timeout_tx_weight(self.context.get_channel_type()) / 1000,
2617 dust_buffer_feerate * htlc_success_tx_weight(self.context.get_channel_type()) / 1000)
2619 let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.context.counterparty_dust_limit_satoshis;
2620 if msg.amount_msat / 1000 < exposure_dust_limit_timeout_sats {
2621 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;
2622 if on_counterparty_tx_dust_htlc_exposure_msat > self.context.get_max_dust_htlc_exposure_msat() {
2623 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on counterparty commitment tx",
2624 on_counterparty_tx_dust_htlc_exposure_msat, self.context.get_max_dust_htlc_exposure_msat());
2625 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2629 let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.context.holder_dust_limit_satoshis;
2630 if msg.amount_msat / 1000 < exposure_dust_limit_success_sats {
2631 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;
2632 if on_holder_tx_dust_htlc_exposure_msat > self.context.get_max_dust_htlc_exposure_msat() {
2633 log_info!(logger, "Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on holder commitment tx",
2634 on_holder_tx_dust_htlc_exposure_msat, self.context.get_max_dust_htlc_exposure_msat());
2635 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2639 let pending_value_to_self_msat =
2640 self.context.value_to_self_msat + inbound_stats.pending_htlcs_value_msat - removed_outbound_total_msat;
2641 let pending_remote_value_msat =
2642 self.context.channel_value_satoshis * 1000 - pending_value_to_self_msat;
2643 if pending_remote_value_msat < msg.amount_msat {
2644 return Err(ChannelError::Close("Remote HTLC add would overdraw remaining funds".to_owned()));
2647 // Check that the remote can afford to pay for this HTLC on-chain at the current
2648 // feerate_per_kw, while maintaining their channel reserve (as required by the spec).
2649 let remote_commit_tx_fee_msat = if self.context.is_outbound() { 0 } else {
2650 let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2651 self.context.next_remote_commit_tx_fee_msat(htlc_candidate, None) // Don't include the extra fee spike buffer HTLC in calculations
2653 if pending_remote_value_msat - msg.amount_msat < remote_commit_tx_fee_msat {
2654 return Err(ChannelError::Close("Remote HTLC add would not leave enough to pay for fees".to_owned()));
2657 if pending_remote_value_msat - msg.amount_msat - remote_commit_tx_fee_msat < self.context.holder_selected_channel_reserve_satoshis * 1000 {
2658 return Err(ChannelError::Close("Remote HTLC add would put them under remote reserve value".to_owned()));
2661 if !self.context.is_outbound() {
2662 // `2 *` and `Some(())` is for the fee spike buffer we keep for the remote. This deviates from
2663 // the spec because in the spec, the fee spike buffer requirement doesn't exist on the
2664 // receiver's side, only on the sender's.
2665 // Note that when we eventually remove support for fee updates and switch to anchor output
2666 // fees, we will drop the `2 *`, since we no longer be as sensitive to fee spikes. But, keep
2667 // the extra htlc when calculating the next remote commitment transaction fee as we should
2668 // still be able to afford adding this HTLC plus one more future HTLC, regardless of being
2669 // sensitive to fee spikes.
2670 let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2671 let remote_fee_cost_incl_stuck_buffer_msat = 2 * self.context.next_remote_commit_tx_fee_msat(htlc_candidate, Some(()));
2672 if pending_remote_value_msat - msg.amount_msat - self.context.holder_selected_channel_reserve_satoshis * 1000 < remote_fee_cost_incl_stuck_buffer_msat {
2673 // Note that if the pending_forward_status is not updated here, then it's because we're already failing
2674 // the HTLC, i.e. its status is already set to failing.
2675 log_info!(logger, "Attempting to fail HTLC due to fee spike buffer violation in channel {}. Rebalancing is required.", log_bytes!(self.context.channel_id()));
2676 pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x1000|7);
2679 // Check that they won't violate our local required channel reserve by adding this HTLC.
2680 let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
2681 let local_commit_tx_fee_msat = self.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
2682 if self.context.value_to_self_msat < self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 + local_commit_tx_fee_msat {
2683 return Err(ChannelError::Close("Cannot accept HTLC that would put our balance under counterparty-announced channel reserve value".to_owned()));
2686 if self.context.next_counterparty_htlc_id != msg.htlc_id {
2687 return Err(ChannelError::Close(format!("Remote skipped HTLC ID (skipped ID: {})", self.context.next_counterparty_htlc_id)));
2689 if msg.cltv_expiry >= 500000000 {
2690 return Err(ChannelError::Close("Remote provided CLTV expiry in seconds instead of block height".to_owned()));
2693 if self.context.channel_state & ChannelState::LocalShutdownSent as u32 != 0 {
2694 if let PendingHTLCStatus::Forward(_) = pending_forward_status {
2695 panic!("ChannelManager shouldn't be trying to add a forwardable HTLC after we've started closing");
2699 // Now update local state:
2700 self.context.next_counterparty_htlc_id += 1;
2701 self.context.pending_inbound_htlcs.push(InboundHTLCOutput {
2702 htlc_id: msg.htlc_id,
2703 amount_msat: msg.amount_msat,
2704 payment_hash: msg.payment_hash,
2705 cltv_expiry: msg.cltv_expiry,
2706 state: InboundHTLCState::RemoteAnnounced(pending_forward_status),
2711 /// Marks an outbound HTLC which we have received update_fail/fulfill/malformed
2713 fn mark_outbound_htlc_removed(&mut self, htlc_id: u64, check_preimage: Option<PaymentPreimage>, fail_reason: Option<HTLCFailReason>) -> Result<&OutboundHTLCOutput, ChannelError> {
2714 assert!(!(check_preimage.is_some() && fail_reason.is_some()), "cannot fail while we have a preimage");
2715 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
2716 if htlc.htlc_id == htlc_id {
2717 let outcome = match check_preimage {
2718 None => fail_reason.into(),
2719 Some(payment_preimage) => {
2720 let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
2721 if payment_hash != htlc.payment_hash {
2722 return Err(ChannelError::Close(format!("Remote tried to fulfill HTLC ({}) with an incorrect preimage", htlc_id)));
2724 OutboundHTLCOutcome::Success(Some(payment_preimage))
2728 OutboundHTLCState::LocalAnnounced(_) =>
2729 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) before it had been committed", htlc_id))),
2730 OutboundHTLCState::Committed => {
2731 htlc.state = OutboundHTLCState::RemoteRemoved(outcome);
2733 OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) | OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) | OutboundHTLCState::RemoteRemoved(_) =>
2734 return Err(ChannelError::Close(format!("Remote tried to fulfill/fail HTLC ({}) that they'd already fulfilled/failed", htlc_id))),
2739 Err(ChannelError::Close("Remote tried to fulfill/fail an HTLC we couldn't find".to_owned()))
2742 pub fn update_fulfill_htlc(&mut self, msg: &msgs::UpdateFulfillHTLC) -> Result<(HTLCSource, u64), ChannelError> {
2743 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2744 return Err(ChannelError::Close("Got fulfill HTLC message when channel was not in an operational state".to_owned()));
2746 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2747 return Err(ChannelError::Close("Peer sent update_fulfill_htlc when we needed a channel_reestablish".to_owned()));
2750 self.mark_outbound_htlc_removed(msg.htlc_id, Some(msg.payment_preimage), None).map(|htlc| (htlc.source.clone(), htlc.amount_msat))
2753 pub fn update_fail_htlc(&mut self, msg: &msgs::UpdateFailHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
2754 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2755 return Err(ChannelError::Close("Got fail HTLC message when channel was not in an operational state".to_owned()));
2757 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2758 return Err(ChannelError::Close("Peer sent update_fail_htlc when we needed a channel_reestablish".to_owned()));
2761 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
2765 pub fn update_fail_malformed_htlc(&mut self, msg: &msgs::UpdateFailMalformedHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
2766 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2767 return Err(ChannelError::Close("Got fail malformed HTLC message when channel was not in an operational state".to_owned()));
2769 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2770 return Err(ChannelError::Close("Peer sent update_fail_malformed_htlc when we needed a channel_reestablish".to_owned()));
2773 self.mark_outbound_htlc_removed(msg.htlc_id, None, Some(fail_reason))?;
2777 pub fn commitment_signed<L: Deref>(&mut self, msg: &msgs::CommitmentSigned, logger: &L) -> Result<Option<ChannelMonitorUpdate>, ChannelError>
2778 where L::Target: Logger
2780 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
2781 return Err(ChannelError::Close("Got commitment signed message when channel was not in an operational state".to_owned()));
2783 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
2784 return Err(ChannelError::Close("Peer sent commitment_signed when we needed a channel_reestablish".to_owned()));
2786 if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.context.last_sent_closing_fee.is_some() {
2787 return Err(ChannelError::Close("Peer sent commitment_signed after we'd started exchanging closing_signeds".to_owned()));
2790 let funding_script = self.context.get_funding_redeemscript();
2792 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
2794 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger);
2795 let commitment_txid = {
2796 let trusted_tx = commitment_stats.tx.trust();
2797 let bitcoin_tx = trusted_tx.built_transaction();
2798 let sighash = bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
2800 log_trace!(logger, "Checking commitment tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}",
2801 log_bytes!(msg.signature.serialize_compact()[..]),
2802 log_bytes!(self.context.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&bitcoin_tx.transaction),
2803 log_bytes!(sighash[..]), encode::serialize_hex(&funding_script), log_bytes!(self.context.channel_id()));
2804 if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.counterparty_funding_pubkey()) {
2805 return Err(ChannelError::Close("Invalid commitment tx signature from peer".to_owned()));
2809 let mut htlcs_cloned: Vec<_> = commitment_stats.htlcs_included.iter().map(|htlc| (htlc.0.clone(), htlc.1.map(|h| h.clone()))).collect();
2811 // If our counterparty updated the channel fee in this commitment transaction, check that
2812 // they can actually afford the new fee now.
2813 let update_fee = if let Some((_, update_state)) = self.context.pending_update_fee {
2814 update_state == FeeUpdateState::RemoteAnnounced
2817 debug_assert!(!self.context.is_outbound());
2818 let counterparty_reserve_we_require_msat = self.context.holder_selected_channel_reserve_satoshis * 1000;
2819 if commitment_stats.remote_balance_msat < commitment_stats.total_fee_sat * 1000 + counterparty_reserve_we_require_msat {
2820 return Err(ChannelError::Close("Funding remote cannot afford proposed new fee".to_owned()));
2823 #[cfg(any(test, fuzzing))]
2825 if self.context.is_outbound() {
2826 let projected_commit_tx_info = self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap().take();
2827 *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
2828 if let Some(info) = projected_commit_tx_info {
2829 let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len()
2830 + self.context.holding_cell_htlc_updates.len();
2831 if info.total_pending_htlcs == total_pending_htlcs
2832 && info.next_holder_htlc_id == self.context.next_holder_htlc_id
2833 && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
2834 && info.feerate == self.context.feerate_per_kw {
2835 assert_eq!(commitment_stats.total_fee_sat, info.fee / 1000);
2841 if msg.htlc_signatures.len() != commitment_stats.num_nondust_htlcs {
2842 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)));
2845 // Up to LDK 0.0.115, HTLC information was required to be duplicated in the
2846 // `htlcs_and_sigs` vec and in the `holder_commitment_tx` itself, both of which were passed
2847 // in the `ChannelMonitorUpdate`. In 0.0.115, support for having a separate set of
2848 // outbound-non-dust-HTLCSources in the `ChannelMonitorUpdate` was added, however for
2849 // backwards compatibility, we never use it in production. To provide test coverage, here,
2850 // we randomly decide (in test/fuzzing builds) to use the new vec sometimes.
2851 #[allow(unused_assignments, unused_mut)]
2852 let mut separate_nondust_htlc_sources = false;
2853 #[cfg(all(feature = "std", any(test, fuzzing)))] {
2854 use core::hash::{BuildHasher, Hasher};
2855 // Get a random value using the only std API to do so - the DefaultHasher
2856 let rand_val = std::collections::hash_map::RandomState::new().build_hasher().finish();
2857 separate_nondust_htlc_sources = rand_val % 2 == 0;
2860 let mut nondust_htlc_sources = Vec::with_capacity(htlcs_cloned.len());
2861 let mut htlcs_and_sigs = Vec::with_capacity(htlcs_cloned.len());
2862 for (idx, (htlc, mut source_opt)) in htlcs_cloned.drain(..).enumerate() {
2863 if let Some(_) = htlc.transaction_output_index {
2864 let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_stats.feerate_per_kw,
2865 self.context.get_counterparty_selected_contest_delay().unwrap(), &htlc, &self.context.channel_type,
2866 &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
2868 let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &keys);
2869 let htlc_sighashtype = if self.context.channel_type.supports_anchors_zero_fee_htlc_tx() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
2870 let htlc_sighash = hash_to_message!(&sighash::SighashCache::new(&htlc_tx).segwit_signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, htlc_sighashtype).unwrap()[..]);
2871 log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}.",
2872 log_bytes!(msg.htlc_signatures[idx].serialize_compact()[..]), log_bytes!(keys.countersignatory_htlc_key.serialize()),
2873 encode::serialize_hex(&htlc_tx), log_bytes!(htlc_sighash[..]), encode::serialize_hex(&htlc_redeemscript), log_bytes!(self.context.channel_id()));
2874 if let Err(_) = self.context.secp_ctx.verify_ecdsa(&htlc_sighash, &msg.htlc_signatures[idx], &keys.countersignatory_htlc_key) {
2875 return Err(ChannelError::Close("Invalid HTLC tx signature from peer".to_owned()));
2877 if !separate_nondust_htlc_sources {
2878 htlcs_and_sigs.push((htlc, Some(msg.htlc_signatures[idx]), source_opt.take()));
2881 htlcs_and_sigs.push((htlc, None, source_opt.take()));
2883 if separate_nondust_htlc_sources {
2884 if let Some(source) = source_opt.take() {
2885 nondust_htlc_sources.push(source);
2888 debug_assert!(source_opt.is_none(), "HTLCSource should have been put somewhere");
2891 let holder_commitment_tx = HolderCommitmentTransaction::new(
2892 commitment_stats.tx,
2894 msg.htlc_signatures.clone(),
2895 &self.context.get_holder_pubkeys().funding_pubkey,
2896 self.context.counterparty_funding_pubkey()
2899 self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
2900 .map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
2902 // Update state now that we've passed all the can-fail calls...
2903 let mut need_commitment = false;
2904 if let &mut Some((_, ref mut update_state)) = &mut self.context.pending_update_fee {
2905 if *update_state == FeeUpdateState::RemoteAnnounced {
2906 *update_state = FeeUpdateState::AwaitingRemoteRevokeToAnnounce;
2907 need_commitment = true;
2911 for htlc in self.context.pending_inbound_htlcs.iter_mut() {
2912 let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
2913 Some(forward_info.clone())
2915 if let Some(forward_info) = new_forward {
2916 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToAnnounce due to commitment_signed in channel {}.",
2917 log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
2918 htlc.state = InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info);
2919 need_commitment = true;
2922 let mut claimed_htlcs = Vec::new();
2923 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
2924 if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
2925 log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
2926 log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
2927 // Grab the preimage, if it exists, instead of cloning
2928 let mut reason = OutboundHTLCOutcome::Success(None);
2929 mem::swap(outcome, &mut reason);
2930 if let OutboundHTLCOutcome::Success(Some(preimage)) = reason {
2931 // If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
2932 // upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
2933 // have a `Success(None)` reason. In this case we could forget some HTLC
2934 // claims, but such an upgrade is unlikely and including claimed HTLCs here
2935 // fixes a bug which the user was exposed to on 0.0.104 when they started the
2937 claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
2939 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
2940 need_commitment = true;
2944 self.context.latest_monitor_update_id += 1;
2945 let mut monitor_update = ChannelMonitorUpdate {
2946 update_id: self.context.latest_monitor_update_id,
2947 updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
2948 commitment_tx: holder_commitment_tx,
2949 htlc_outputs: htlcs_and_sigs,
2951 nondust_htlc_sources,
2955 self.context.cur_holder_commitment_transaction_number -= 1;
2956 // Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
2957 // build_commitment_no_status_check() next which will reset this to RAAFirst.
2958 self.context.resend_order = RAACommitmentOrder::CommitmentFirst;
2960 if (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0 {
2961 // In case we initially failed monitor updating without requiring a response, we need
2962 // to make sure the RAA gets sent first.
2963 self.context.monitor_pending_revoke_and_ack = true;
2964 if need_commitment && (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
2965 // If we were going to send a commitment_signed after the RAA, go ahead and do all
2966 // the corresponding HTLC status updates so that get_last_commitment_update
2967 // includes the right HTLCs.
2968 self.context.monitor_pending_commitment_signed = true;
2969 let mut additional_update = self.build_commitment_no_status_check(logger);
2970 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
2971 // strictly increasing by one, so decrement it here.
2972 self.context.latest_monitor_update_id = monitor_update.update_id;
2973 monitor_update.updates.append(&mut additional_update.updates);
2975 log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updated HTLC state but awaiting a monitor update resolution to reply.",
2976 log_bytes!(self.context.channel_id));
2977 return Ok(self.push_ret_blockable_mon_update(monitor_update));
2980 let need_commitment_signed = if need_commitment && (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
2981 // If we're AwaitingRemoteRevoke we can't send a new commitment here, but that's ok -
2982 // we'll send one right away when we get the revoke_and_ack when we
2983 // free_holding_cell_htlcs().
2984 let mut additional_update = self.build_commitment_no_status_check(logger);
2985 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
2986 // strictly increasing by one, so decrement it here.
2987 self.context.latest_monitor_update_id = monitor_update.update_id;
2988 monitor_update.updates.append(&mut additional_update.updates);
2992 log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updating HTLC state and responding with{} a revoke_and_ack.",
2993 log_bytes!(self.context.channel_id()), if need_commitment_signed { " our own commitment_signed and" } else { "" });
2994 self.monitor_updating_paused(true, need_commitment_signed, false, Vec::new(), Vec::new(), Vec::new());
2995 return Ok(self.push_ret_blockable_mon_update(monitor_update));
2998 /// Public version of the below, checking relevant preconditions first.
2999 /// If we're not in a state where freeing the holding cell makes sense, this is a no-op and
3000 /// returns `(None, Vec::new())`.
3001 pub fn maybe_free_holding_cell_htlcs<L: Deref>(&mut self, logger: &L) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
3002 if self.context.channel_state >= ChannelState::ChannelReady as u32 &&
3003 (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) == 0 {
3004 self.free_holding_cell_htlcs(logger)
3005 } else { (None, Vec::new()) }
3008 /// Frees any pending commitment updates in the holding cell, generating the relevant messages
3009 /// for our counterparty.
3010 fn free_holding_cell_htlcs<L: Deref>(&mut self, logger: &L) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
3011 assert_eq!(self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32, 0);
3012 if self.context.holding_cell_htlc_updates.len() != 0 || self.context.holding_cell_update_fee.is_some() {
3013 log_trace!(logger, "Freeing holding cell with {} HTLC updates{} in channel {}", self.context.holding_cell_htlc_updates.len(),
3014 if self.context.holding_cell_update_fee.is_some() { " and a fee update" } else { "" }, log_bytes!(self.context.channel_id()));
3016 let mut monitor_update = ChannelMonitorUpdate {
3017 update_id: self.context.latest_monitor_update_id + 1, // We don't increment this yet!
3018 updates: Vec::new(),
3021 let mut htlc_updates = Vec::new();
3022 mem::swap(&mut htlc_updates, &mut self.context.holding_cell_htlc_updates);
3023 let mut update_add_htlcs = Vec::with_capacity(htlc_updates.len());
3024 let mut update_fulfill_htlcs = Vec::with_capacity(htlc_updates.len());
3025 let mut update_fail_htlcs = Vec::with_capacity(htlc_updates.len());
3026 let mut htlcs_to_fail = Vec::new();
3027 for htlc_update in htlc_updates.drain(..) {
3028 // Note that this *can* fail, though it should be due to rather-rare conditions on
3029 // fee races with adding too many outputs which push our total payments just over
3030 // the limit. In case it's less rare than I anticipate, we may want to revisit
3031 // handling this case better and maybe fulfilling some of the HTLCs while attempting
3032 // to rebalance channels.
3033 match &htlc_update {
3034 &HTLCUpdateAwaitingACK::AddHTLC {
3035 amount_msat, cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet,
3036 skimmed_fee_msat, ..
3038 match self.send_htlc(amount_msat, *payment_hash, cltv_expiry, source.clone(),
3039 onion_routing_packet.clone(), false, skimmed_fee_msat, logger)
3041 Ok(update_add_msg_option) => update_add_htlcs.push(update_add_msg_option.unwrap()),
3044 ChannelError::Ignore(ref msg) => {
3045 log_info!(logger, "Failed to send HTLC with payment_hash {} due to {} in channel {}",
3046 log_bytes!(payment_hash.0), msg, log_bytes!(self.context.channel_id()));
3047 // If we fail to send here, then this HTLC should
3048 // be failed backwards. Failing to send here
3049 // indicates that this HTLC may keep being put back
3050 // into the holding cell without ever being
3051 // successfully forwarded/failed/fulfilled, causing
3052 // our counterparty to eventually close on us.
3053 htlcs_to_fail.push((source.clone(), *payment_hash));
3056 panic!("Got a non-IgnoreError action trying to send holding cell HTLC");
3062 &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, htlc_id, .. } => {
3063 // If an HTLC claim was previously added to the holding cell (via
3064 // `get_update_fulfill_htlc`, then generating the claim message itself must
3065 // not fail - any in between attempts to claim the HTLC will have resulted
3066 // in it hitting the holding cell again and we cannot change the state of a
3067 // holding cell HTLC from fulfill to anything else.
3068 let (update_fulfill_msg_option, mut additional_monitor_update) =
3069 if let UpdateFulfillFetch::NewClaim { msg, monitor_update, .. } = self.get_update_fulfill_htlc(htlc_id, *payment_preimage, logger) {
3070 (msg, monitor_update)
3071 } else { unreachable!() };
3072 update_fulfill_htlcs.push(update_fulfill_msg_option.unwrap());
3073 monitor_update.updates.append(&mut additional_monitor_update.updates);
3075 &HTLCUpdateAwaitingACK::FailHTLC { htlc_id, ref err_packet } => {
3076 match self.fail_htlc(htlc_id, err_packet.clone(), false, logger) {
3077 Ok(update_fail_msg_option) => {
3078 // If an HTLC failure was previously added to the holding cell (via
3079 // `queue_fail_htlc`) then generating the fail message itself must
3080 // not fail - we should never end up in a state where we double-fail
3081 // an HTLC or fail-then-claim an HTLC as it indicates we didn't wait
3082 // for a full revocation before failing.
3083 update_fail_htlcs.push(update_fail_msg_option.unwrap())
3086 if let ChannelError::Ignore(_) = e {}
3088 panic!("Got a non-IgnoreError action trying to fail holding cell HTLC");
3095 if update_add_htlcs.is_empty() && update_fulfill_htlcs.is_empty() && update_fail_htlcs.is_empty() && self.context.holding_cell_update_fee.is_none() {
3096 return (None, htlcs_to_fail);
3098 let update_fee = if let Some(feerate) = self.context.holding_cell_update_fee.take() {
3099 self.send_update_fee(feerate, false, logger)
3104 let mut additional_update = self.build_commitment_no_status_check(logger);
3105 // build_commitment_no_status_check and get_update_fulfill_htlc may bump latest_monitor_id
3106 // but we want them to be strictly increasing by one, so reset it here.
3107 self.context.latest_monitor_update_id = monitor_update.update_id;
3108 monitor_update.updates.append(&mut additional_update.updates);
3110 log_debug!(logger, "Freeing holding cell in channel {} resulted in {}{} HTLCs added, {} HTLCs fulfilled, and {} HTLCs failed.",
3111 log_bytes!(self.context.channel_id()), if update_fee.is_some() { "a fee update, " } else { "" },
3112 update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len());
3114 self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
3115 (self.push_ret_blockable_mon_update(monitor_update), htlcs_to_fail)
3121 /// Handles receiving a remote's revoke_and_ack. Note that we may return a new
3122 /// commitment_signed message here in case we had pending outbound HTLCs to add which were
3123 /// waiting on this revoke_and_ack. The generation of this new commitment_signed may also fail,
3124 /// generating an appropriate error *after* the channel state has been updated based on the
3125 /// revoke_and_ack message.
3126 pub fn revoke_and_ack<L: Deref>(&mut self, msg: &msgs::RevokeAndACK, logger: &L) -> Result<(Vec<(HTLCSource, PaymentHash)>, Option<ChannelMonitorUpdate>), ChannelError>
3127 where L::Target: Logger,
3129 if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
3130 return Err(ChannelError::Close("Got revoke/ACK message when channel was not in an operational state".to_owned()));
3132 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3133 return Err(ChannelError::Close("Peer sent revoke_and_ack when we needed a channel_reestablish".to_owned()));
3135 if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.context.last_sent_closing_fee.is_some() {
3136 return Err(ChannelError::Close("Peer sent revoke_and_ack after we'd started exchanging closing_signeds".to_owned()));
3139 let secret = secp_check!(SecretKey::from_slice(&msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret".to_owned());
3141 if let Some(counterparty_prev_commitment_point) = self.context.counterparty_prev_commitment_point {
3142 if PublicKey::from_secret_key(&self.context.secp_ctx, &secret) != counterparty_prev_commitment_point {
3143 return Err(ChannelError::Close("Got a revoke commitment secret which didn't correspond to their current pubkey".to_owned()));
3147 if self.context.channel_state & ChannelState::AwaitingRemoteRevoke as u32 == 0 {
3148 // Our counterparty seems to have burned their coins to us (by revoking a state when we
3149 // haven't given them a new commitment transaction to broadcast). We should probably
3150 // take advantage of this by updating our channel monitor, sending them an error, and
3151 // waiting for them to broadcast their latest (now-revoked claim). But, that would be a
3152 // lot of work, and there's some chance this is all a misunderstanding anyway.
3153 // We have to do *something*, though, since our signer may get mad at us for otherwise
3154 // jumping a remote commitment number, so best to just force-close and move on.
3155 return Err(ChannelError::Close("Received an unexpected revoke_and_ack".to_owned()));
3158 #[cfg(any(test, fuzzing))]
3160 *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
3161 *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
3164 self.context.holder_signer.validate_counterparty_revocation(
3165 self.context.cur_counterparty_commitment_transaction_number + 1,
3167 ).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
3169 self.context.commitment_secrets.provide_secret(self.context.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
3170 .map_err(|_| ChannelError::Close("Previous secrets did not match new one".to_owned()))?;
3171 self.context.latest_monitor_update_id += 1;
3172 let mut monitor_update = ChannelMonitorUpdate {
3173 update_id: self.context.latest_monitor_update_id,
3174 updates: vec![ChannelMonitorUpdateStep::CommitmentSecret {
3175 idx: self.context.cur_counterparty_commitment_transaction_number + 1,
3176 secret: msg.per_commitment_secret,
3180 // Update state now that we've passed all the can-fail calls...
3181 // (note that we may still fail to generate the new commitment_signed message, but that's
3182 // OK, we step the channel here and *then* if the new generation fails we can fail the
3183 // channel based on that, but stepping stuff here should be safe either way.
3184 self.context.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32);
3185 self.context.sent_message_awaiting_response = None;
3186 self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
3187 self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
3188 self.context.cur_counterparty_commitment_transaction_number -= 1;
3190 if self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
3191 self.context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
3194 log_trace!(logger, "Updating HTLCs on receipt of RAA in channel {}...", log_bytes!(self.context.channel_id()));
3195 let mut to_forward_infos = Vec::new();
3196 let mut revoked_htlcs = Vec::new();
3197 let mut finalized_claimed_htlcs = Vec::new();
3198 let mut update_fail_htlcs = Vec::new();
3199 let mut update_fail_malformed_htlcs = Vec::new();
3200 let mut require_commitment = false;
3201 let mut value_to_self_msat_diff: i64 = 0;
3204 // Take references explicitly so that we can hold multiple references to self.context.
3205 let pending_inbound_htlcs: &mut Vec<_> = &mut self.context.pending_inbound_htlcs;
3206 let pending_outbound_htlcs: &mut Vec<_> = &mut self.context.pending_outbound_htlcs;
3208 // We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
3209 pending_inbound_htlcs.retain(|htlc| {
3210 if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
3211 log_trace!(logger, " ...removing inbound LocalRemoved {}", log_bytes!(htlc.payment_hash.0));
3212 if let &InboundHTLCRemovalReason::Fulfill(_) = reason {
3213 value_to_self_msat_diff += htlc.amount_msat as i64;
3218 pending_outbound_htlcs.retain(|htlc| {
3219 if let &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) = &htlc.state {
3220 log_trace!(logger, " ...removing outbound AwaitingRemovedRemoteRevoke {}", log_bytes!(htlc.payment_hash.0));
3221 if let OutboundHTLCOutcome::Failure(reason) = outcome.clone() { // We really want take() here, but, again, non-mut ref :(
3222 revoked_htlcs.push((htlc.source.clone(), htlc.payment_hash, reason));
3224 finalized_claimed_htlcs.push(htlc.source.clone());
3225 // They fulfilled, so we sent them money
3226 value_to_self_msat_diff -= htlc.amount_msat as i64;
3231 for htlc in pending_inbound_htlcs.iter_mut() {
3232 let swap = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) = &htlc.state {
3234 } else if let &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) = &htlc.state {
3238 let mut state = InboundHTLCState::Committed;
3239 mem::swap(&mut state, &mut htlc.state);
3241 if let InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info) = state {
3242 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
3243 htlc.state = InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info);
3244 require_commitment = true;
3245 } else if let InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info) = state {
3246 match forward_info {
3247 PendingHTLCStatus::Fail(fail_msg) => {
3248 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to LocalRemoved due to PendingHTLCStatus indicating failure", log_bytes!(htlc.payment_hash.0));
3249 require_commitment = true;
3251 HTLCFailureMsg::Relay(msg) => {
3252 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(msg.reason.clone()));
3253 update_fail_htlcs.push(msg)
3255 HTLCFailureMsg::Malformed(msg) => {
3256 htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed((msg.sha256_of_onion, msg.failure_code)));
3257 update_fail_malformed_htlcs.push(msg)
3261 PendingHTLCStatus::Forward(forward_info) => {
3262 log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed", log_bytes!(htlc.payment_hash.0));
3263 to_forward_infos.push((forward_info, htlc.htlc_id));
3264 htlc.state = InboundHTLCState::Committed;
3270 for htlc in pending_outbound_htlcs.iter_mut() {
3271 if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
3272 log_trace!(logger, " ...promoting outbound LocalAnnounced {} to Committed", log_bytes!(htlc.payment_hash.0));
3273 htlc.state = OutboundHTLCState::Committed;
3275 if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
3276 log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
3277 // Grab the preimage, if it exists, instead of cloning
3278 let mut reason = OutboundHTLCOutcome::Success(None);
3279 mem::swap(outcome, &mut reason);
3280 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
3281 require_commitment = true;
3285 self.context.value_to_self_msat = (self.context.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
3287 if let Some((feerate, update_state)) = self.context.pending_update_fee {
3288 match update_state {
3289 FeeUpdateState::Outbound => {
3290 debug_assert!(self.context.is_outbound());
3291 log_trace!(logger, " ...promoting outbound fee update {} to Committed", feerate);
3292 self.context.feerate_per_kw = feerate;
3293 self.context.pending_update_fee = None;
3295 FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.context.is_outbound()); },
3296 FeeUpdateState::AwaitingRemoteRevokeToAnnounce => {
3297 debug_assert!(!self.context.is_outbound());
3298 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
3299 require_commitment = true;
3300 self.context.feerate_per_kw = feerate;
3301 self.context.pending_update_fee = None;
3306 if (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) == ChannelState::MonitorUpdateInProgress as u32 {
3307 // We can't actually generate a new commitment transaction (incl by freeing holding
3308 // cells) while we can't update the monitor, so we just return what we have.
3309 if require_commitment {
3310 self.context.monitor_pending_commitment_signed = true;
3311 // When the monitor updating is restored we'll call get_last_commitment_update(),
3312 // which does not update state, but we're definitely now awaiting a remote revoke
3313 // before we can step forward any more, so set it here.
3314 let mut additional_update = self.build_commitment_no_status_check(logger);
3315 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3316 // strictly increasing by one, so decrement it here.
3317 self.context.latest_monitor_update_id = monitor_update.update_id;
3318 monitor_update.updates.append(&mut additional_update.updates);
3320 self.context.monitor_pending_forwards.append(&mut to_forward_infos);
3321 self.context.monitor_pending_failures.append(&mut revoked_htlcs);
3322 self.context.monitor_pending_finalized_fulfills.append(&mut finalized_claimed_htlcs);
3323 log_debug!(logger, "Received a valid revoke_and_ack for channel {} but awaiting a monitor update resolution to reply.", log_bytes!(self.context.channel_id()));
3324 return Ok((Vec::new(), self.push_ret_blockable_mon_update(monitor_update)));
3327 match self.free_holding_cell_htlcs(logger) {
3328 (Some(mut additional_update), htlcs_to_fail) => {
3329 // free_holding_cell_htlcs may bump latest_monitor_id multiple times but we want them to be
3330 // strictly increasing by one, so decrement it here.
3331 self.context.latest_monitor_update_id = monitor_update.update_id;
3332 monitor_update.updates.append(&mut additional_update.updates);
3334 self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3335 Ok((htlcs_to_fail, self.push_ret_blockable_mon_update(monitor_update)))
3337 (None, htlcs_to_fail) => {
3338 if require_commitment {
3339 let mut additional_update = self.build_commitment_no_status_check(logger);
3341 // build_commitment_no_status_check may bump latest_monitor_id but we want them to be
3342 // strictly increasing by one, so decrement it here.
3343 self.context.latest_monitor_update_id = monitor_update.update_id;
3344 monitor_update.updates.append(&mut additional_update.updates);
3346 log_debug!(logger, "Received a valid revoke_and_ack for channel {}. Responding with a commitment update with {} HTLCs failed.",
3347 log_bytes!(self.context.channel_id()), update_fail_htlcs.len() + update_fail_malformed_htlcs.len());
3348 self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3349 Ok((htlcs_to_fail, self.push_ret_blockable_mon_update(monitor_update)))
3351 log_debug!(logger, "Received a valid revoke_and_ack for channel {} with no reply necessary.", log_bytes!(self.context.channel_id()));
3352 self.monitor_updating_paused(false, false, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
3353 Ok((htlcs_to_fail, self.push_ret_blockable_mon_update(monitor_update)))
3359 /// Queues up an outbound update fee by placing it in the holding cell. You should call
3360 /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
3361 /// commitment update.
3362 pub fn queue_update_fee<L: Deref>(&mut self, feerate_per_kw: u32, logger: &L) where L::Target: Logger {
3363 let msg_opt = self.send_update_fee(feerate_per_kw, true, logger);
3364 assert!(msg_opt.is_none(), "We forced holding cell?");
3367 /// Adds a pending update to this channel. See the doc for send_htlc for
3368 /// further details on the optionness of the return value.
3369 /// If our balance is too low to cover the cost of the next commitment transaction at the
3370 /// new feerate, the update is cancelled.
3372 /// You MUST call [`Self::send_commitment_no_state_update`] prior to any other calls on this
3373 /// [`Channel`] if `force_holding_cell` is false.
3374 fn send_update_fee<L: Deref>(&mut self, feerate_per_kw: u32, mut force_holding_cell: bool, logger: &L) -> Option<msgs::UpdateFee> where L::Target: Logger {
3375 if !self.context.is_outbound() {
3376 panic!("Cannot send fee from inbound channel");
3378 if !self.context.is_usable() {
3379 panic!("Cannot update fee until channel is fully established and we haven't started shutting down");
3381 if !self.context.is_live() {
3382 panic!("Cannot update fee while peer is disconnected/we're awaiting a monitor update (ChannelManager should have caught this)");
3385 // Before proposing a feerate update, check that we can actually afford the new fee.
3386 let inbound_stats = self.context.get_inbound_pending_htlc_stats(Some(feerate_per_kw));
3387 let outbound_stats = self.context.get_outbound_pending_htlc_stats(Some(feerate_per_kw));
3388 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
3389 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, true, logger);
3390 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;
3391 let holder_balance_msat = commitment_stats.local_balance_msat - outbound_stats.holding_cell_msat;
3392 if holder_balance_msat < buffer_fee_msat + self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 {
3393 //TODO: auto-close after a number of failures?
3394 log_debug!(logger, "Cannot afford to send new feerate at {}", feerate_per_kw);
3398 // Note, we evaluate pending htlc "preemptive" trimmed-to-dust threshold at the proposed `feerate_per_kw`.
3399 let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
3400 let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
3401 if holder_tx_dust_exposure > self.context.get_max_dust_htlc_exposure_msat() {
3402 log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
3405 if counterparty_tx_dust_exposure > self.context.get_max_dust_htlc_exposure_msat() {
3406 log_debug!(logger, "Cannot afford to send new feerate at {} without infringing max dust htlc exposure", feerate_per_kw);
3410 if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
3411 force_holding_cell = true;
3414 if force_holding_cell {
3415 self.context.holding_cell_update_fee = Some(feerate_per_kw);
3419 debug_assert!(self.context.pending_update_fee.is_none());
3420 self.context.pending_update_fee = Some((feerate_per_kw, FeeUpdateState::Outbound));
3422 Some(msgs::UpdateFee {
3423 channel_id: self.context.channel_id,
3428 /// Removes any uncommitted inbound HTLCs and resets the state of uncommitted outbound HTLC
3429 /// updates, to be used on peer disconnection. After this, update_*_htlc messages need to be
3431 /// No further message handling calls may be made until a channel_reestablish dance has
3433 pub fn remove_uncommitted_htlcs_and_mark_paused<L: Deref>(&mut self, logger: &L) where L::Target: Logger {
3434 assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
3435 if self.context.channel_state < ChannelState::FundingSent as u32 {
3436 self.context.channel_state = ChannelState::ShutdownComplete as u32;
3440 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == (ChannelState::PeerDisconnected as u32) {
3441 // While the below code should be idempotent, it's simpler to just return early, as
3442 // redundant disconnect events can fire, though they should be rare.
3446 if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent || self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
3447 self.context.announcement_sigs_state = AnnouncementSigsState::NotSent;
3450 // Upon reconnect we have to start the closing_signed dance over, but shutdown messages
3451 // will be retransmitted.
3452 self.context.last_sent_closing_fee = None;
3453 self.context.pending_counterparty_closing_signed = None;
3454 self.context.closing_fee_limits = None;
3456 let mut inbound_drop_count = 0;
3457 self.context.pending_inbound_htlcs.retain(|htlc| {
3459 InboundHTLCState::RemoteAnnounced(_) => {
3460 // They sent us an update_add_htlc but we never got the commitment_signed.
3461 // We'll tell them what commitment_signed we're expecting next and they'll drop
3462 // this HTLC accordingly
3463 inbound_drop_count += 1;
3466 InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_)|InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => {
3467 // We received a commitment_signed updating this HTLC and (at least hopefully)
3468 // sent a revoke_and_ack (which we can re-transmit) and have heard nothing
3469 // in response to it yet, so don't touch it.
3472 InboundHTLCState::Committed => true,
3473 InboundHTLCState::LocalRemoved(_) => {
3474 // We (hopefully) sent a commitment_signed updating this HTLC (which we can
3475 // re-transmit if needed) and they may have even sent a revoke_and_ack back
3476 // (that we missed). Keep this around for now and if they tell us they missed
3477 // the commitment_signed we can re-transmit the update then.
3482 self.context.next_counterparty_htlc_id -= inbound_drop_count;
3484 if let Some((_, update_state)) = self.context.pending_update_fee {
3485 if update_state == FeeUpdateState::RemoteAnnounced {
3486 debug_assert!(!self.context.is_outbound());
3487 self.context.pending_update_fee = None;
3491 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
3492 if let OutboundHTLCState::RemoteRemoved(_) = htlc.state {
3493 // They sent us an update to remove this but haven't yet sent the corresponding
3494 // commitment_signed, we need to move it back to Committed and they can re-send
3495 // the update upon reconnection.
3496 htlc.state = OutboundHTLCState::Committed;
3500 self.context.sent_message_awaiting_response = None;
3502 self.context.channel_state |= ChannelState::PeerDisconnected as u32;
3503 log_trace!(logger, "Peer disconnection resulted in {} remote-announced HTLC drops on channel {}", inbound_drop_count, log_bytes!(self.context.channel_id()));
3506 /// Indicates that a ChannelMonitor update is in progress and has not yet been fully persisted.
3507 /// This must be called before we return the [`ChannelMonitorUpdate`] back to the
3508 /// [`ChannelManager`], which will call [`Self::monitor_updating_restored`] once the monitor
3509 /// update completes (potentially immediately).
3510 /// The messages which were generated with the monitor update must *not* have been sent to the
3511 /// remote end, and must instead have been dropped. They will be regenerated when
3512 /// [`Self::monitor_updating_restored`] is called.
3514 /// [`ChannelManager`]: super::channelmanager::ChannelManager
3515 /// [`chain::Watch`]: crate::chain::Watch
3516 /// [`ChannelMonitorUpdateStatus::InProgress`]: crate::chain::ChannelMonitorUpdateStatus::InProgress
3517 fn monitor_updating_paused(&mut self, resend_raa: bool, resend_commitment: bool,
3518 resend_channel_ready: bool, mut pending_forwards: Vec<(PendingHTLCInfo, u64)>,
3519 mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
3520 mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
3522 self.context.monitor_pending_revoke_and_ack |= resend_raa;
3523 self.context.monitor_pending_commitment_signed |= resend_commitment;
3524 self.context.monitor_pending_channel_ready |= resend_channel_ready;
3525 self.context.monitor_pending_forwards.append(&mut pending_forwards);
3526 self.context.monitor_pending_failures.append(&mut pending_fails);
3527 self.context.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
3528 self.context.channel_state |= ChannelState::MonitorUpdateInProgress as u32;
3531 /// Indicates that the latest ChannelMonitor update has been committed by the client
3532 /// successfully and we should restore normal operation. Returns messages which should be sent
3533 /// to the remote side.
3534 pub fn monitor_updating_restored<L: Deref, NS: Deref>(
3535 &mut self, logger: &L, node_signer: &NS, genesis_block_hash: BlockHash,
3536 user_config: &UserConfig, best_block_height: u32
3537 ) -> MonitorRestoreUpdates
3540 NS::Target: NodeSigner
3542 assert_eq!(self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32, ChannelState::MonitorUpdateInProgress as u32);
3543 self.context.channel_state &= !(ChannelState::MonitorUpdateInProgress as u32);
3545 // If we're past (or at) the FundingSent stage on an outbound channel, try to
3546 // (re-)broadcast the funding transaction as we may have declined to broadcast it when we
3547 // first received the funding_signed.
3548 let mut funding_broadcastable =
3549 if self.context.is_outbound() && self.context.channel_state & !MULTI_STATE_FLAGS >= ChannelState::FundingSent as u32 {
3550 self.context.funding_transaction.take()
3552 // That said, if the funding transaction is already confirmed (ie we're active with a
3553 // minimum_depth over 0) don't bother re-broadcasting the confirmed funding tx.
3554 if self.context.channel_state & !MULTI_STATE_FLAGS >= ChannelState::ChannelReady as u32 && self.context.minimum_depth != Some(0) {
3555 funding_broadcastable = None;
3558 // We will never broadcast the funding transaction when we're in MonitorUpdateInProgress
3559 // (and we assume the user never directly broadcasts the funding transaction and waits for
3560 // us to do it). Thus, we can only ever hit monitor_pending_channel_ready when we're
3561 // * an inbound channel that failed to persist the monitor on funding_created and we got
3562 // the funding transaction confirmed before the monitor was persisted, or
3563 // * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
3564 let channel_ready = if self.context.monitor_pending_channel_ready {
3565 assert!(!self.context.is_outbound() || self.context.minimum_depth == Some(0),
3566 "Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
3567 self.context.monitor_pending_channel_ready = false;
3568 let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
3569 Some(msgs::ChannelReady {
3570 channel_id: self.context.channel_id(),
3571 next_per_commitment_point,
3572 short_channel_id_alias: Some(self.context.outbound_scid_alias),
3576 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block_height, logger);
3578 let mut accepted_htlcs = Vec::new();
3579 mem::swap(&mut accepted_htlcs, &mut self.context.monitor_pending_forwards);
3580 let mut failed_htlcs = Vec::new();
3581 mem::swap(&mut failed_htlcs, &mut self.context.monitor_pending_failures);
3582 let mut finalized_claimed_htlcs = Vec::new();
3583 mem::swap(&mut finalized_claimed_htlcs, &mut self.context.monitor_pending_finalized_fulfills);
3585 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) != 0 {
3586 self.context.monitor_pending_revoke_and_ack = false;
3587 self.context.monitor_pending_commitment_signed = false;
3588 return MonitorRestoreUpdates {
3589 raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
3590 accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
3594 let raa = if self.context.monitor_pending_revoke_and_ack {
3595 Some(self.get_last_revoke_and_ack())
3597 let commitment_update = if self.context.monitor_pending_commitment_signed {
3598 self.mark_awaiting_response();
3599 Some(self.get_last_commitment_update(logger))
3602 self.context.monitor_pending_revoke_and_ack = false;
3603 self.context.monitor_pending_commitment_signed = false;
3604 let order = self.context.resend_order.clone();
3605 log_debug!(logger, "Restored monitor updating in channel {} resulting in {}{} commitment update and {} RAA, with {} first",
3606 log_bytes!(self.context.channel_id()), if funding_broadcastable.is_some() { "a funding broadcastable, " } else { "" },
3607 if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
3608 match order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
3609 MonitorRestoreUpdates {
3610 raa, commitment_update, order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
3614 pub fn update_fee<F: Deref, L: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::UpdateFee, logger: &L) -> Result<(), ChannelError>
3615 where F::Target: FeeEstimator, L::Target: Logger
3617 if self.context.is_outbound() {
3618 return Err(ChannelError::Close("Non-funding remote tried to update channel fee".to_owned()));
3620 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
3621 return Err(ChannelError::Close("Peer sent update_fee when we needed a channel_reestablish".to_owned()));
3623 Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, Some(self.context.feerate_per_kw), logger)?;
3624 let feerate_over_dust_buffer = msg.feerate_per_kw > self.context.get_dust_buffer_feerate(None);
3626 self.context.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
3627 self.context.update_time_counter += 1;
3628 // If the feerate has increased over the previous dust buffer (note that
3629 // `get_dust_buffer_feerate` considers the `pending_update_fee` status), check that we
3630 // won't be pushed over our dust exposure limit by the feerate increase.
3631 if feerate_over_dust_buffer {
3632 let inbound_stats = self.context.get_inbound_pending_htlc_stats(None);
3633 let outbound_stats = self.context.get_outbound_pending_htlc_stats(None);
3634 let holder_tx_dust_exposure = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat;
3635 let counterparty_tx_dust_exposure = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
3636 if holder_tx_dust_exposure > self.context.get_max_dust_htlc_exposure_msat() {
3637 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)",
3638 msg.feerate_per_kw, holder_tx_dust_exposure)));
3640 if counterparty_tx_dust_exposure > self.context.get_max_dust_htlc_exposure_msat() {
3641 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)",
3642 msg.feerate_per_kw, counterparty_tx_dust_exposure)));
3648 fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
3649 let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
3650 let per_commitment_secret = self.context.holder_signer.release_commitment_secret(self.context.cur_holder_commitment_transaction_number + 2);
3651 msgs::RevokeAndACK {
3652 channel_id: self.context.channel_id,
3653 per_commitment_secret,
3654 next_per_commitment_point,
3656 next_local_nonce: None,
3660 fn get_last_commitment_update<L: Deref>(&self, logger: &L) -> msgs::CommitmentUpdate where L::Target: Logger {
3661 let mut update_add_htlcs = Vec::new();
3662 let mut update_fulfill_htlcs = Vec::new();
3663 let mut update_fail_htlcs = Vec::new();
3664 let mut update_fail_malformed_htlcs = Vec::new();
3666 for htlc in self.context.pending_outbound_htlcs.iter() {
3667 if let &OutboundHTLCState::LocalAnnounced(ref onion_packet) = &htlc.state {
3668 update_add_htlcs.push(msgs::UpdateAddHTLC {
3669 channel_id: self.context.channel_id(),
3670 htlc_id: htlc.htlc_id,
3671 amount_msat: htlc.amount_msat,
3672 payment_hash: htlc.payment_hash,
3673 cltv_expiry: htlc.cltv_expiry,
3674 onion_routing_packet: (**onion_packet).clone(),
3675 skimmed_fee_msat: htlc.skimmed_fee_msat,
3680 for htlc in self.context.pending_inbound_htlcs.iter() {
3681 if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
3683 &InboundHTLCRemovalReason::FailRelay(ref err_packet) => {
3684 update_fail_htlcs.push(msgs::UpdateFailHTLC {
3685 channel_id: self.context.channel_id(),
3686 htlc_id: htlc.htlc_id,
3687 reason: err_packet.clone()
3690 &InboundHTLCRemovalReason::FailMalformed((ref sha256_of_onion, ref failure_code)) => {
3691 update_fail_malformed_htlcs.push(msgs::UpdateFailMalformedHTLC {
3692 channel_id: self.context.channel_id(),
3693 htlc_id: htlc.htlc_id,
3694 sha256_of_onion: sha256_of_onion.clone(),
3695 failure_code: failure_code.clone(),
3698 &InboundHTLCRemovalReason::Fulfill(ref payment_preimage) => {
3699 update_fulfill_htlcs.push(msgs::UpdateFulfillHTLC {
3700 channel_id: self.context.channel_id(),
3701 htlc_id: htlc.htlc_id,
3702 payment_preimage: payment_preimage.clone(),
3709 let update_fee = if self.context.is_outbound() && self.context.pending_update_fee.is_some() {
3710 Some(msgs::UpdateFee {
3711 channel_id: self.context.channel_id(),
3712 feerate_per_kw: self.context.pending_update_fee.unwrap().0,
3716 log_trace!(logger, "Regenerated latest commitment update in channel {} with{} {} update_adds, {} update_fulfills, {} update_fails, and {} update_fail_malformeds",
3717 log_bytes!(self.context.channel_id()), if update_fee.is_some() { " update_fee," } else { "" },
3718 update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len(), update_fail_malformed_htlcs.len());
3719 msgs::CommitmentUpdate {
3720 update_add_htlcs, update_fulfill_htlcs, update_fail_htlcs, update_fail_malformed_htlcs, update_fee,
3721 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,
3725 /// May panic if some calls other than message-handling calls (which will all Err immediately)
3726 /// have been called between remove_uncommitted_htlcs_and_mark_paused and this call.
3728 /// Some links printed in log lines are included here to check them during build (when run with
3729 /// `cargo doc --document-private-items`):
3730 /// [`super::channelmanager::ChannelManager::force_close_without_broadcasting_txn`] and
3731 /// [`super::channelmanager::ChannelManager::force_close_all_channels_without_broadcasting_txn`].
3732 pub fn channel_reestablish<L: Deref, NS: Deref>(
3733 &mut self, msg: &msgs::ChannelReestablish, logger: &L, node_signer: &NS,
3734 genesis_block_hash: BlockHash, user_config: &UserConfig, best_block: &BestBlock
3735 ) -> Result<ReestablishResponses, ChannelError>
3738 NS::Target: NodeSigner
3740 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
3741 // While BOLT 2 doesn't indicate explicitly we should error this channel here, it
3742 // almost certainly indicates we are going to end up out-of-sync in some way, so we
3743 // just close here instead of trying to recover.
3744 return Err(ChannelError::Close("Peer sent a loose channel_reestablish not after reconnect".to_owned()));
3747 if msg.next_local_commitment_number >= INITIAL_COMMITMENT_NUMBER || msg.next_remote_commitment_number >= INITIAL_COMMITMENT_NUMBER ||
3748 msg.next_local_commitment_number == 0 {
3749 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()));
3752 if msg.next_remote_commitment_number > 0 {
3753 let expected_point = self.context.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.context.secp_ctx);
3754 let given_secret = SecretKey::from_slice(&msg.your_last_per_commitment_secret)
3755 .map_err(|_| ChannelError::Close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
3756 if expected_point != PublicKey::from_secret_key(&self.context.secp_ctx, &given_secret) {
3757 return Err(ChannelError::Close("Peer sent a garbage channel_reestablish with secret key not matching the commitment height provided".to_owned()));
3759 if msg.next_remote_commitment_number > INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number {
3760 macro_rules! log_and_panic {
3761 ($err_msg: expr) => {
3762 log_error!(logger, $err_msg, log_bytes!(self.context.channel_id), log_pubkey!(self.context.counterparty_node_id));
3763 panic!($err_msg, log_bytes!(self.context.channel_id), log_pubkey!(self.context.counterparty_node_id));
3766 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\
3767 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\
3768 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\
3769 If you have restored from an old backup and wish to force-close channels and return to operation, you should start up, call\n\
3770 ChannelManager::force_close_without_broadcasting_txn on channel {} with counterparty {} or\n\
3771 ChannelManager::force_close_all_channels_without_broadcasting_txn, then reconnect to peer(s).\n\
3772 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\
3773 See https://github.com/lightningdevkit/rust-lightning/issues/1565 for more info.");
3777 // Before we change the state of the channel, we check if the peer is sending a very old
3778 // commitment transaction number, if yes we send a warning message.
3779 let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number - 1;
3780 if msg.next_remote_commitment_number + 1 < our_commitment_transaction {
3782 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))
3786 // Go ahead and unmark PeerDisconnected as various calls we may make check for it (and all
3787 // remaining cases either succeed or ErrorMessage-fail).
3788 self.context.channel_state &= !(ChannelState::PeerDisconnected as u32);
3789 self.context.sent_message_awaiting_response = None;
3791 let shutdown_msg = if self.context.channel_state & (ChannelState::LocalShutdownSent as u32) != 0 {
3792 assert!(self.context.shutdown_scriptpubkey.is_some());
3793 Some(msgs::Shutdown {
3794 channel_id: self.context.channel_id,
3795 scriptpubkey: self.get_closing_scriptpubkey(),
3799 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block.height(), logger);
3801 if self.context.channel_state & (ChannelState::FundingSent as u32) == ChannelState::FundingSent as u32 {
3802 // If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
3803 if self.context.channel_state & (ChannelState::OurChannelReady as u32) == 0 ||
3804 self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
3805 if msg.next_remote_commitment_number != 0 {
3806 return Err(ChannelError::Close("Peer claimed they saw a revoke_and_ack but we haven't sent channel_ready yet".to_owned()));
3808 // Short circuit the whole handler as there is nothing we can resend them
3809 return Ok(ReestablishResponses {
3810 channel_ready: None,
3811 raa: None, commitment_update: None,
3812 order: RAACommitmentOrder::CommitmentFirst,
3813 shutdown_msg, announcement_sigs,
3817 // We have OurChannelReady set!
3818 let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
3819 return Ok(ReestablishResponses {
3820 channel_ready: Some(msgs::ChannelReady {
3821 channel_id: self.context.channel_id(),
3822 next_per_commitment_point,
3823 short_channel_id_alias: Some(self.context.outbound_scid_alias),
3825 raa: None, commitment_update: None,
3826 order: RAACommitmentOrder::CommitmentFirst,
3827 shutdown_msg, announcement_sigs,
3831 let required_revoke = if msg.next_remote_commitment_number + 1 == INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number {
3832 // Remote isn't waiting on any RevokeAndACK from us!
3833 // Note that if we need to repeat our ChannelReady we'll do that in the next if block.
3835 } else if msg.next_remote_commitment_number + 1 == (INITIAL_COMMITMENT_NUMBER - 1) - self.context.cur_holder_commitment_transaction_number {
3836 if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
3837 self.context.monitor_pending_revoke_and_ack = true;
3840 Some(self.get_last_revoke_and_ack())
3843 return Err(ChannelError::Close("Peer attempted to reestablish channel with a very old local commitment transaction".to_owned()));
3846 // We increment cur_counterparty_commitment_transaction_number only upon receipt of
3847 // revoke_and_ack, not on sending commitment_signed, so we add one if have
3848 // AwaitingRemoteRevoke set, which indicates we sent a commitment_signed but haven't gotten
3849 // the corresponding revoke_and_ack back yet.
3850 let is_awaiting_remote_revoke = self.context.channel_state & ChannelState::AwaitingRemoteRevoke as u32 != 0;
3851 if is_awaiting_remote_revoke && !self.is_awaiting_monitor_update() {
3852 self.mark_awaiting_response();
3854 let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };
3856 let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number == 1 {
3857 // We should never have to worry about MonitorUpdateInProgress resending ChannelReady
3858 let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
3859 Some(msgs::ChannelReady {
3860 channel_id: self.context.channel_id(),
3861 next_per_commitment_point,
3862 short_channel_id_alias: Some(self.context.outbound_scid_alias),
3866 if msg.next_local_commitment_number == next_counterparty_commitment_number {
3867 if required_revoke.is_some() {
3868 log_debug!(logger, "Reconnected channel {} with only lost outbound RAA", log_bytes!(self.context.channel_id()));
3870 log_debug!(logger, "Reconnected channel {} with no loss", log_bytes!(self.context.channel_id()));
3873 Ok(ReestablishResponses {
3874 channel_ready, shutdown_msg, announcement_sigs,
3875 raa: required_revoke,
3876 commitment_update: None,
3877 order: self.context.resend_order.clone(),
3879 } else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
3880 if required_revoke.is_some() {
3881 log_debug!(logger, "Reconnected channel {} with lost outbound RAA and lost remote commitment tx", log_bytes!(self.context.channel_id()));
3883 log_debug!(logger, "Reconnected channel {} with only lost remote commitment tx", log_bytes!(self.context.channel_id()));
3886 if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
3887 self.context.monitor_pending_commitment_signed = true;
3888 Ok(ReestablishResponses {
3889 channel_ready, shutdown_msg, announcement_sigs,
3890 commitment_update: None, raa: None,
3891 order: self.context.resend_order.clone(),
3894 Ok(ReestablishResponses {
3895 channel_ready, shutdown_msg, announcement_sigs,
3896 raa: required_revoke,
3897 commitment_update: Some(self.get_last_commitment_update(logger)),
3898 order: self.context.resend_order.clone(),
3902 Err(ChannelError::Close("Peer attempted to reestablish channel with a very old remote commitment transaction".to_owned()))
3906 /// Calculates and returns our minimum and maximum closing transaction fee amounts, in whole
3907 /// satoshis. The amounts remain consistent unless a peer disconnects/reconnects or we restart,
3908 /// at which point they will be recalculated.
3909 fn calculate_closing_fee_limits<F: Deref>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>)
3911 where F::Target: FeeEstimator
3913 if let Some((min, max)) = self.context.closing_fee_limits { return (min, max); }
3915 // Propose a range from our current Background feerate to our Normal feerate plus our
3916 // force_close_avoidance_max_fee_satoshis.
3917 // If we fail to come to consensus, we'll have to force-close.
3918 let mut proposed_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Background);
3919 let normal_feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Normal);
3920 let mut proposed_max_feerate = if self.context.is_outbound() { normal_feerate } else { u32::max_value() };
3922 // The spec requires that (when the channel does not have anchors) we only send absolute
3923 // channel fees no greater than the absolute channel fee on the current commitment
3924 // transaction. It's unclear *which* commitment transaction this refers to, and there isn't
3925 // very good reason to apply such a limit in any case. We don't bother doing so, risking
3926 // some force-closure by old nodes, but we wanted to close the channel anyway.
3928 if let Some(target_feerate) = self.context.target_closing_feerate_sats_per_kw {
3929 let min_feerate = if self.context.is_outbound() { target_feerate } else { cmp::min(self.context.feerate_per_kw, target_feerate) };
3930 proposed_feerate = cmp::max(proposed_feerate, min_feerate);
3931 proposed_max_feerate = cmp::max(proposed_max_feerate, min_feerate);
3934 // Note that technically we could end up with a lower minimum fee if one sides' balance is
3935 // below our dust limit, causing the output to disappear. We don't bother handling this
3936 // case, however, as this should only happen if a channel is closed before any (material)
3937 // payments have been made on it. This may cause slight fee overpayment and/or failure to
3938 // come to consensus with our counterparty on appropriate fees, however it should be a
3939 // relatively rare case. We can revisit this later, though note that in order to determine
3940 // if the funders' output is dust we have to know the absolute fee we're going to use.
3941 let tx_weight = self.get_closing_transaction_weight(Some(&self.get_closing_scriptpubkey()), Some(self.context.counterparty_shutdown_scriptpubkey.as_ref().unwrap()));
3942 let proposed_total_fee_satoshis = proposed_feerate as u64 * tx_weight / 1000;
3943 let proposed_max_total_fee_satoshis = if self.context.is_outbound() {
3944 // We always add force_close_avoidance_max_fee_satoshis to our normal
3945 // feerate-calculated fee, but allow the max to be overridden if we're using a
3946 // target feerate-calculated fee.
3947 cmp::max(normal_feerate as u64 * tx_weight / 1000 + self.context.config.options.force_close_avoidance_max_fee_satoshis,
3948 proposed_max_feerate as u64 * tx_weight / 1000)
3950 self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 1000
3953 self.context.closing_fee_limits = Some((proposed_total_fee_satoshis, proposed_max_total_fee_satoshis));
3954 self.context.closing_fee_limits.clone().unwrap()
3957 /// Returns true if we're ready to commence the closing_signed negotiation phase. This is true
3958 /// after both sides have exchanged a `shutdown` message and all HTLCs have been drained. At
3959 /// this point if we're the funder we should send the initial closing_signed, and in any case
3960 /// shutdown should complete within a reasonable timeframe.
3961 fn closing_negotiation_ready(&self) -> bool {
3962 self.context.pending_inbound_htlcs.is_empty() && self.context.pending_outbound_htlcs.is_empty() &&
3963 self.context.channel_state &
3964 (BOTH_SIDES_SHUTDOWN_MASK | ChannelState::AwaitingRemoteRevoke as u32 |
3965 ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
3966 == BOTH_SIDES_SHUTDOWN_MASK &&
3967 self.context.pending_update_fee.is_none()
3970 /// Checks if the closing_signed negotiation is making appropriate progress, possibly returning
3971 /// an Err if no progress is being made and the channel should be force-closed instead.
3972 /// Should be called on a one-minute timer.
3973 pub fn timer_check_closing_negotiation_progress(&mut self) -> Result<(), ChannelError> {
3974 if self.closing_negotiation_ready() {
3975 if self.context.closing_signed_in_flight {
3976 return Err(ChannelError::Close("closing_signed negotiation failed to finish within two timer ticks".to_owned()));
3978 self.context.closing_signed_in_flight = true;
3984 pub fn maybe_propose_closing_signed<F: Deref, L: Deref>(
3985 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L)
3986 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
3987 where F::Target: FeeEstimator, L::Target: Logger
3989 if self.context.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
3990 return Ok((None, None));
3993 if !self.context.is_outbound() {
3994 if let Some(msg) = &self.context.pending_counterparty_closing_signed.take() {
3995 return self.closing_signed(fee_estimator, &msg);
3997 return Ok((None, None));
4000 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
4002 assert!(self.context.shutdown_scriptpubkey.is_some());
4003 let (closing_tx, total_fee_satoshis) = self.build_closing_transaction(our_min_fee, false);
4004 log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
4005 our_min_fee, our_max_fee, total_fee_satoshis);
4007 let sig = self.context.holder_signer
4008 .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
4009 .map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
4011 self.context.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
4012 Ok((Some(msgs::ClosingSigned {
4013 channel_id: self.context.channel_id,
4014 fee_satoshis: total_fee_satoshis,
4016 fee_range: Some(msgs::ClosingSignedFeeRange {
4017 min_fee_satoshis: our_min_fee,
4018 max_fee_satoshis: our_max_fee,
4023 // Marks a channel as waiting for a response from the counterparty. If it's not received
4024 // [`DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`] after sending our own to them, then we'll attempt
4026 fn mark_awaiting_response(&mut self) {
4027 self.context.sent_message_awaiting_response = Some(0);
4030 /// Determines whether we should disconnect the counterparty due to not receiving a response
4031 /// within our expected timeframe.
4033 /// This should be called on every [`super::channelmanager::ChannelManager::timer_tick_occurred`].
4034 pub fn should_disconnect_peer_awaiting_response(&mut self) -> bool {
4035 let ticks_elapsed = if let Some(ticks_elapsed) = self.context.sent_message_awaiting_response.as_mut() {
4038 // Don't disconnect when we're not waiting on a response.
4041 *ticks_elapsed += 1;
4042 *ticks_elapsed >= DISCONNECT_PEER_AWAITING_RESPONSE_TICKS
4045 pub fn shutdown<SP: Deref>(
4046 &mut self, signer_provider: &SP, their_features: &InitFeatures, msg: &msgs::Shutdown
4047 ) -> Result<(Option<msgs::Shutdown>, Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), ChannelError>
4048 where SP::Target: SignerProvider
4050 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
4051 return Err(ChannelError::Close("Peer sent shutdown when we needed a channel_reestablish".to_owned()));
4053 if self.context.channel_state < ChannelState::FundingSent as u32 {
4054 // Spec says we should fail the connection, not the channel, but that's nonsense, there
4055 // are plenty of reasons you may want to fail a channel pre-funding, and spec says you
4056 // can do that via error message without getting a connection fail anyway...
4057 return Err(ChannelError::Close("Peer sent shutdown pre-funding generation".to_owned()));
4059 for htlc in self.context.pending_inbound_htlcs.iter() {
4060 if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
4061 return Err(ChannelError::Close("Got shutdown with remote pending HTLCs".to_owned()));
4064 assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
4066 if !script::is_bolt2_compliant(&msg.scriptpubkey, their_features) {
4067 return Err(ChannelError::Warn(format!("Got a nonstandard scriptpubkey ({}) from remote peer", msg.scriptpubkey.to_bytes().to_hex())));
4070 if self.context.counterparty_shutdown_scriptpubkey.is_some() {
4071 if Some(&msg.scriptpubkey) != self.context.counterparty_shutdown_scriptpubkey.as_ref() {
4072 return Err(ChannelError::Warn(format!("Got shutdown request with a scriptpubkey ({}) which did not match their previous scriptpubkey.", msg.scriptpubkey.to_bytes().to_hex())));
4075 self.context.counterparty_shutdown_scriptpubkey = Some(msg.scriptpubkey.clone());
4078 // If we have any LocalAnnounced updates we'll probably just get back an update_fail_htlc
4079 // immediately after the commitment dance, but we can send a Shutdown because we won't send
4080 // any further commitment updates after we set LocalShutdownSent.
4081 let send_shutdown = (self.context.channel_state & ChannelState::LocalShutdownSent as u32) != ChannelState::LocalShutdownSent as u32;
4083 let update_shutdown_script = match self.context.shutdown_scriptpubkey {
4086 assert!(send_shutdown);
4087 let shutdown_scriptpubkey = match signer_provider.get_shutdown_scriptpubkey() {
4088 Ok(scriptpubkey) => scriptpubkey,
4089 Err(_) => return Err(ChannelError::Close("Failed to get shutdown scriptpubkey".to_owned())),
4091 if !shutdown_scriptpubkey.is_compatible(their_features) {
4092 return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
4094 self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
4099 // From here on out, we may not fail!
4101 self.context.channel_state |= ChannelState::RemoteShutdownSent as u32;
4102 self.context.update_time_counter += 1;
4104 let monitor_update = if update_shutdown_script {
4105 self.context.latest_monitor_update_id += 1;
4106 let monitor_update = ChannelMonitorUpdate {
4107 update_id: self.context.latest_monitor_update_id,
4108 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
4109 scriptpubkey: self.get_closing_scriptpubkey(),
4112 self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
4113 self.push_ret_blockable_mon_update(monitor_update)
4115 let shutdown = if send_shutdown {
4116 Some(msgs::Shutdown {
4117 channel_id: self.context.channel_id,
4118 scriptpubkey: self.get_closing_scriptpubkey(),
4122 // We can't send our shutdown until we've committed all of our pending HTLCs, but the
4123 // remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding
4124 // cell HTLCs and return them to fail the payment.
4125 self.context.holding_cell_update_fee = None;
4126 let mut dropped_outbound_htlcs = Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
4127 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
4129 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
4130 dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
4137 self.context.channel_state |= ChannelState::LocalShutdownSent as u32;
4138 self.context.update_time_counter += 1;
4140 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
4143 fn build_signed_closing_transaction(&self, closing_tx: &ClosingTransaction, counterparty_sig: &Signature, sig: &Signature) -> Transaction {
4144 let mut tx = closing_tx.trust().built_transaction().clone();
4146 tx.input[0].witness.push(Vec::new()); // First is the multisig dummy
4148 let funding_key = self.context.get_holder_pubkeys().funding_pubkey.serialize();
4149 let counterparty_funding_key = self.context.counterparty_funding_pubkey().serialize();
4150 let mut holder_sig = sig.serialize_der().to_vec();
4151 holder_sig.push(EcdsaSighashType::All as u8);
4152 let mut cp_sig = counterparty_sig.serialize_der().to_vec();
4153 cp_sig.push(EcdsaSighashType::All as u8);
4154 if funding_key[..] < counterparty_funding_key[..] {
4155 tx.input[0].witness.push(holder_sig);
4156 tx.input[0].witness.push(cp_sig);
4158 tx.input[0].witness.push(cp_sig);
4159 tx.input[0].witness.push(holder_sig);
4162 tx.input[0].witness.push(self.context.get_funding_redeemscript().into_bytes());
4166 pub fn closing_signed<F: Deref>(
4167 &mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::ClosingSigned)
4168 -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
4169 where F::Target: FeeEstimator
4171 if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
4172 return Err(ChannelError::Close("Remote end sent us a closing_signed before both sides provided a shutdown".to_owned()));
4174 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
4175 return Err(ChannelError::Close("Peer sent closing_signed when we needed a channel_reestablish".to_owned()));
4177 if !self.context.pending_inbound_htlcs.is_empty() || !self.context.pending_outbound_htlcs.is_empty() {
4178 return Err(ChannelError::Close("Remote end sent us a closing_signed while there were still pending HTLCs".to_owned()));
4180 if msg.fee_satoshis > TOTAL_BITCOIN_SUPPLY_SATOSHIS { // this is required to stop potential overflow in build_closing_transaction
4181 return Err(ChannelError::Close("Remote tried to send us a closing tx with > 21 million BTC fee".to_owned()));
4184 if self.context.is_outbound() && self.context.last_sent_closing_fee.is_none() {
4185 return Err(ChannelError::Close("Remote tried to send a closing_signed when we were supposed to propose the first one".to_owned()));
4188 if self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32 != 0 {
4189 self.context.pending_counterparty_closing_signed = Some(msg.clone());
4190 return Ok((None, None));
4193 let funding_redeemscript = self.context.get_funding_redeemscript();
4194 let (mut closing_tx, used_total_fee) = self.build_closing_transaction(msg.fee_satoshis, false);
4195 if used_total_fee != msg.fee_satoshis {
4196 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)));
4198 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
4200 match self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.context.get_counterparty_pubkeys().funding_pubkey) {
4203 // The remote end may have decided to revoke their output due to inconsistent dust
4204 // limits, so check for that case by re-checking the signature here.
4205 closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
4206 let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
4207 secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, self.context.counterparty_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
4211 for outp in closing_tx.trust().built_transaction().output.iter() {
4212 if !outp.script_pubkey.is_witness_program() && outp.value < MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS {
4213 return Err(ChannelError::Close("Remote sent us a closing_signed with a dust output. Always use segwit closing scripts!".to_owned()));
4217 assert!(self.context.shutdown_scriptpubkey.is_some());
4218 if let Some((last_fee, sig)) = self.context.last_sent_closing_fee {
4219 if last_fee == msg.fee_satoshis {
4220 let tx = self.build_signed_closing_transaction(&mut closing_tx, &msg.signature, &sig);
4221 self.context.channel_state = ChannelState::ShutdownComplete as u32;
4222 self.context.update_time_counter += 1;
4223 return Ok((None, Some(tx)));
4227 let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
4229 macro_rules! propose_fee {
4230 ($new_fee: expr) => {
4231 let (closing_tx, used_fee) = if $new_fee == msg.fee_satoshis {
4232 (closing_tx, $new_fee)
4234 self.build_closing_transaction($new_fee, false)
4237 let sig = self.context.holder_signer
4238 .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
4239 .map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
4241 let signed_tx = if $new_fee == msg.fee_satoshis {
4242 self.context.channel_state = ChannelState::ShutdownComplete as u32;
4243 self.context.update_time_counter += 1;
4244 let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
4248 self.context.last_sent_closing_fee = Some((used_fee, sig.clone()));
4249 return Ok((Some(msgs::ClosingSigned {
4250 channel_id: self.context.channel_id,
4251 fee_satoshis: used_fee,
4253 fee_range: Some(msgs::ClosingSignedFeeRange {
4254 min_fee_satoshis: our_min_fee,
4255 max_fee_satoshis: our_max_fee,
4261 if let Some(msgs::ClosingSignedFeeRange { min_fee_satoshis, max_fee_satoshis }) = msg.fee_range {
4262 if msg.fee_satoshis < min_fee_satoshis || msg.fee_satoshis > max_fee_satoshis {
4263 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)));
4265 if max_fee_satoshis < our_min_fee {
4266 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)));
4268 if min_fee_satoshis > our_max_fee {
4269 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)));
4272 if !self.context.is_outbound() {
4273 // They have to pay, so pick the highest fee in the overlapping range.
4274 // We should never set an upper bound aside from their full balance
4275 debug_assert_eq!(our_max_fee, self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 1000);
4276 propose_fee!(cmp::min(max_fee_satoshis, our_max_fee));
4278 if msg.fee_satoshis < our_min_fee || msg.fee_satoshis > our_max_fee {
4279 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.",
4280 msg.fee_satoshis, our_min_fee, our_max_fee)));
4282 // The proposed fee is in our acceptable range, accept it and broadcast!
4283 propose_fee!(msg.fee_satoshis);
4286 // Old fee style negotiation. We don't bother to enforce whether they are complying
4287 // with the "making progress" requirements, we just comply and hope for the best.
4288 if let Some((last_fee, _)) = self.context.last_sent_closing_fee {
4289 if msg.fee_satoshis > last_fee {
4290 if msg.fee_satoshis < our_max_fee {
4291 propose_fee!(msg.fee_satoshis);
4292 } else if last_fee < our_max_fee {
4293 propose_fee!(our_max_fee);
4295 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)));
4298 if msg.fee_satoshis > our_min_fee {
4299 propose_fee!(msg.fee_satoshis);
4300 } else if last_fee > our_min_fee {
4301 propose_fee!(our_min_fee);
4303 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)));
4307 if msg.fee_satoshis < our_min_fee {
4308 propose_fee!(our_min_fee);
4309 } else if msg.fee_satoshis > our_max_fee {
4310 propose_fee!(our_max_fee);
4312 propose_fee!(msg.fee_satoshis);
4318 fn internal_htlc_satisfies_config(
4319 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32, config: &ChannelConfig,
4320 ) -> Result<(), (&'static str, u16)> {
4321 let fee = amt_to_forward.checked_mul(config.forwarding_fee_proportional_millionths as u64)
4322 .and_then(|prop_fee| (prop_fee / 1000000).checked_add(config.forwarding_fee_base_msat as u64));
4323 if fee.is_none() || htlc.amount_msat < fee.unwrap() ||
4324 (htlc.amount_msat - fee.unwrap()) < amt_to_forward {
4326 "Prior hop has deviated from specified fees parameters or origin node has obsolete ones",
4327 0x1000 | 12, // fee_insufficient
4330 if (htlc.cltv_expiry as u64) < outgoing_cltv_value as u64 + config.cltv_expiry_delta as u64 {
4332 "Forwarding node has tampered with the intended HTLC values or origin node has an obsolete cltv_expiry_delta",
4333 0x1000 | 13, // incorrect_cltv_expiry
4339 /// Determines whether the parameters of an incoming HTLC to be forwarded satisfy the channel's
4340 /// [`ChannelConfig`]. This first looks at the channel's current [`ChannelConfig`], and if
4341 /// unsuccessful, falls back to the previous one if one exists.
4342 pub fn htlc_satisfies_config(
4343 &self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32,
4344 ) -> Result<(), (&'static str, u16)> {
4345 self.internal_htlc_satisfies_config(&htlc, amt_to_forward, outgoing_cltv_value, &self.context.config())
4347 if let Some(prev_config) = self.context.prev_config() {
4348 self.internal_htlc_satisfies_config(htlc, amt_to_forward, outgoing_cltv_value, &prev_config)
4355 pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
4356 self.context.cur_holder_commitment_transaction_number + 1
4359 pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
4360 self.context.cur_counterparty_commitment_transaction_number + 1 - if self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 }
4363 pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
4364 self.context.cur_counterparty_commitment_transaction_number + 2
4368 pub fn get_signer(&self) -> &Signer {
4369 &self.context.holder_signer
4373 pub fn get_value_stat(&self) -> ChannelValueStat {
4375 value_to_self_msat: self.context.value_to_self_msat,
4376 channel_value_msat: self.context.channel_value_satoshis * 1000,
4377 channel_reserve_msat: self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000,
4378 pending_outbound_htlcs_amount_msat: self.context.pending_outbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
4379 pending_inbound_htlcs_amount_msat: self.context.pending_inbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
4380 holding_cell_outbound_amount_msat: {
4382 for h in self.context.holding_cell_htlc_updates.iter() {
4384 &HTLCUpdateAwaitingACK::AddHTLC{amount_msat, .. } => {
4392 counterparty_max_htlc_value_in_flight_msat: self.context.counterparty_max_htlc_value_in_flight_msat,
4393 counterparty_dust_limit_msat: self.context.counterparty_dust_limit_satoshis * 1000,
4397 /// Returns true if this channel has been marked as awaiting a monitor update to move forward.
4398 /// Allowed in any state (including after shutdown)
4399 pub fn is_awaiting_monitor_update(&self) -> bool {
4400 (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0
4403 /// Gets the latest [`ChannelMonitorUpdate`] ID which has been released and is in-flight.
4404 pub fn get_latest_unblocked_monitor_update_id(&self) -> u64 {
4405 if self.context.blocked_monitor_updates.is_empty() { return self.context.get_latest_monitor_update_id(); }
4406 self.context.blocked_monitor_updates[0].update.update_id - 1
4409 /// Returns the next blocked monitor update, if one exists, and a bool which indicates a
4410 /// further blocked monitor update exists after the next.
4411 pub fn unblock_next_blocked_monitor_update(&mut self) -> Option<(ChannelMonitorUpdate, bool)> {
4412 if self.context.blocked_monitor_updates.is_empty() { return None; }
4413 Some((self.context.blocked_monitor_updates.remove(0).update,
4414 !self.context.blocked_monitor_updates.is_empty()))
4417 /// Pushes a new monitor update into our monitor update queue, returning it if it should be
4418 /// immediately given to the user for persisting or `None` if it should be held as blocked.
4419 fn push_ret_blockable_mon_update(&mut self, update: ChannelMonitorUpdate)
4420 -> Option<ChannelMonitorUpdate> {
4421 let release_monitor = self.context.blocked_monitor_updates.is_empty();
4422 if !release_monitor {
4423 self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
4432 pub fn blocked_monitor_updates_pending(&self) -> usize {
4433 self.context.blocked_monitor_updates.len()
4436 /// Returns true if the channel is awaiting the persistence of the initial ChannelMonitor.
4437 /// If the channel is outbound, this implies we have not yet broadcasted the funding
4438 /// transaction. If the channel is inbound, this implies simply that the channel has not
4440 pub fn is_awaiting_initial_mon_persist(&self) -> bool {
4441 if !self.is_awaiting_monitor_update() { return false; }
4442 if self.context.channel_state &
4443 !(ChannelState::TheirChannelReady as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
4444 == ChannelState::FundingSent as u32 {
4445 // If we're not a 0conf channel, we'll be waiting on a monitor update with only
4446 // FundingSent set, though our peer could have sent their channel_ready.
4447 debug_assert!(self.context.minimum_depth.unwrap_or(1) > 0);
4450 if self.context.cur_holder_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 &&
4451 self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
4452 // If we're a 0-conf channel, we'll move beyond FundingSent immediately even while
4453 // waiting for the initial monitor persistence. Thus, we check if our commitment
4454 // transaction numbers have both been iterated only exactly once (for the
4455 // funding_signed), and we're awaiting monitor update.
4457 // If we got here, we shouldn't have yet broadcasted the funding transaction (as the
4458 // only way to get an awaiting-monitor-update state during initial funding is if the
4459 // initial monitor persistence is still pending).
4461 // Because deciding we're awaiting initial broadcast spuriously could result in
4462 // funds-loss (as we don't have a monitor, but have the funding transaction confirmed),
4463 // we hard-assert here, even in production builds.
4464 if self.context.is_outbound() { assert!(self.context.funding_transaction.is_some()); }
4465 assert!(self.context.monitor_pending_channel_ready);
4466 assert_eq!(self.context.latest_monitor_update_id, 0);
4472 /// Returns true if our channel_ready has been sent
4473 pub fn is_our_channel_ready(&self) -> bool {
4474 (self.context.channel_state & ChannelState::OurChannelReady as u32) != 0 || self.context.channel_state >= ChannelState::ChannelReady as u32
4477 /// Returns true if our peer has either initiated or agreed to shut down the channel.
4478 pub fn received_shutdown(&self) -> bool {
4479 (self.context.channel_state & ChannelState::RemoteShutdownSent as u32) != 0
4482 /// Returns true if we either initiated or agreed to shut down the channel.
4483 pub fn sent_shutdown(&self) -> bool {
4484 (self.context.channel_state & ChannelState::LocalShutdownSent as u32) != 0
4487 /// Returns true if this channel is fully shut down. True here implies that no further actions
4488 /// may/will be taken on this channel, and thus this object should be freed. Any future changes
4489 /// will be handled appropriately by the chain monitor.
4490 pub fn is_shutdown(&self) -> bool {
4491 if (self.context.channel_state & ChannelState::ShutdownComplete as u32) == ChannelState::ShutdownComplete as u32 {
4492 assert!(self.context.channel_state == ChannelState::ShutdownComplete as u32);
4497 pub fn channel_update_status(&self) -> ChannelUpdateStatus {
4498 self.context.channel_update_status
4501 pub fn set_channel_update_status(&mut self, status: ChannelUpdateStatus) {
4502 self.context.update_time_counter += 1;
4503 self.context.channel_update_status = status;
4506 fn check_get_channel_ready(&mut self, height: u32) -> Option<msgs::ChannelReady> {
4508 // * always when a new block/transactions are confirmed with the new height
4509 // * when funding is signed with a height of 0
4510 if self.context.funding_tx_confirmation_height == 0 && self.context.minimum_depth != Some(0) {
4514 let funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
4515 if funding_tx_confirmations <= 0 {
4516 self.context.funding_tx_confirmation_height = 0;
4519 if funding_tx_confirmations < self.context.minimum_depth.unwrap_or(0) as i64 {
4523 let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
4524 let need_commitment_update = if non_shutdown_state == ChannelState::FundingSent as u32 {
4525 self.context.channel_state |= ChannelState::OurChannelReady as u32;
4527 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) {
4528 self.context.channel_state = ChannelState::ChannelReady as u32 | (self.context.channel_state & MULTI_STATE_FLAGS);
4529 self.context.update_time_counter += 1;
4531 } else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
4532 // We got a reorg but not enough to trigger a force close, just ignore.
4535 if self.context.funding_tx_confirmation_height != 0 && self.context.channel_state < ChannelState::ChannelReady as u32 {
4536 // We should never see a funding transaction on-chain until we've received
4537 // funding_signed (if we're an outbound channel), or seen funding_generated (if we're
4538 // an inbound channel - before that we have no known funding TXID). The fuzzer,
4539 // however, may do this and we shouldn't treat it as a bug.
4540 #[cfg(not(fuzzing))]
4541 panic!("Started confirming a channel in a state pre-FundingSent: {}.\n\
4542 Do NOT broadcast a funding transaction manually - let LDK do it for you!",
4543 self.context.channel_state);
4545 // We got a reorg but not enough to trigger a force close, just ignore.
4549 if need_commitment_update {
4550 if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
4551 if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
4552 let next_per_commitment_point =
4553 self.context.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.context.secp_ctx);
4554 return Some(msgs::ChannelReady {
4555 channel_id: self.context.channel_id,
4556 next_per_commitment_point,
4557 short_channel_id_alias: Some(self.context.outbound_scid_alias),
4561 self.context.monitor_pending_channel_ready = true;
4567 /// When a transaction is confirmed, we check whether it is or spends the funding transaction
4568 /// In the first case, we store the confirmation height and calculating the short channel id.
4569 /// In the second, we simply return an Err indicating we need to be force-closed now.
4570 pub fn transactions_confirmed<NS: Deref, L: Deref>(
4571 &mut self, block_hash: &BlockHash, height: u32, txdata: &TransactionData,
4572 genesis_block_hash: BlockHash, node_signer: &NS, user_config: &UserConfig, logger: &L
4573 ) -> Result<(Option<msgs::ChannelReady>, Option<msgs::AnnouncementSignatures>), ClosureReason>
4575 NS::Target: NodeSigner,
4578 if let Some(funding_txo) = self.context.get_funding_txo() {
4579 for &(index_in_block, tx) in txdata.iter() {
4580 // Check if the transaction is the expected funding transaction, and if it is,
4581 // check that it pays the right amount to the right script.
4582 if self.context.funding_tx_confirmation_height == 0 {
4583 if tx.txid() == funding_txo.txid {
4584 let txo_idx = funding_txo.index as usize;
4585 if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.context.get_funding_redeemscript().to_v0_p2wsh() ||
4586 tx.output[txo_idx].value != self.context.channel_value_satoshis {
4587 if self.context.is_outbound() {
4588 // If we generated the funding transaction and it doesn't match what it
4589 // should, the client is really broken and we should just panic and
4590 // tell them off. That said, because hash collisions happen with high
4591 // probability in fuzzing mode, if we're fuzzing we just close the
4592 // channel and move on.
4593 #[cfg(not(fuzzing))]
4594 panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
4596 self.context.update_time_counter += 1;
4597 let err_reason = "funding tx had wrong script/value or output index";
4598 return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
4600 if self.context.is_outbound() {
4601 for input in tx.input.iter() {
4602 if input.witness.is_empty() {
4603 // We generated a malleable funding transaction, implying we've
4604 // just exposed ourselves to funds loss to our counterparty.
4605 #[cfg(not(fuzzing))]
4606 panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
4610 self.context.funding_tx_confirmation_height = height;
4611 self.context.funding_tx_confirmed_in = Some(*block_hash);
4612 self.context.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
4613 Ok(scid) => Some(scid),
4614 Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
4618 // If we allow 1-conf funding, we may need to check for channel_ready here and
4619 // send it immediately instead of waiting for a best_block_updated call (which
4620 // may have already happened for this block).
4621 if let Some(channel_ready) = self.check_get_channel_ready(height) {
4622 log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.context.channel_id));
4623 let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger);
4624 return Ok((Some(channel_ready), announcement_sigs));
4627 for inp in tx.input.iter() {
4628 if inp.previous_output == funding_txo.into_bitcoin_outpoint() {
4629 log_info!(logger, "Detected channel-closing tx {} spending {}:{}, closing channel {}", tx.txid(), inp.previous_output.txid, inp.previous_output.vout, log_bytes!(self.context.channel_id()));
4630 return Err(ClosureReason::CommitmentTxConfirmed);
4638 /// When a new block is connected, we check the height of the block against outbound holding
4639 /// cell HTLCs in case we need to give up on them prematurely and time them out. Everything
4640 /// else (e.g. commitment transaction broadcasts, HTLC transaction broadcasting, etc) is
4641 /// handled by the ChannelMonitor.
4643 /// If we return Err, the channel may have been closed, at which point the standard
4644 /// requirements apply - no calls may be made except those explicitly stated to be allowed
4647 /// May return some HTLCs (and their payment_hash) which have timed out and should be failed
4649 pub fn best_block_updated<NS: Deref, L: Deref>(
4650 &mut self, height: u32, highest_header_time: u32, genesis_block_hash: BlockHash,
4651 node_signer: &NS, user_config: &UserConfig, logger: &L
4652 ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
4654 NS::Target: NodeSigner,
4657 self.do_best_block_updated(height, highest_header_time, Some((genesis_block_hash, node_signer, user_config)), logger)
4660 fn do_best_block_updated<NS: Deref, L: Deref>(
4661 &mut self, height: u32, highest_header_time: u32,
4662 genesis_node_signer: Option<(BlockHash, &NS, &UserConfig)>, logger: &L
4663 ) -> Result<(Option<msgs::ChannelReady>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>), ClosureReason>
4665 NS::Target: NodeSigner,
4668 let mut timed_out_htlcs = Vec::new();
4669 // This mirrors the check in ChannelManager::decode_update_add_htlc_onion, refusing to
4670 // forward an HTLC when our counterparty should almost certainly just fail it for expiring
4672 let unforwarded_htlc_cltv_limit = height + LATENCY_GRACE_PERIOD_BLOCKS;
4673 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
4675 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, ref cltv_expiry, .. } => {
4676 if *cltv_expiry <= unforwarded_htlc_cltv_limit {
4677 timed_out_htlcs.push((source.clone(), payment_hash.clone()));
4685 self.context.update_time_counter = cmp::max(self.context.update_time_counter, highest_header_time);
4687 if let Some(channel_ready) = self.check_get_channel_ready(height) {
4688 let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
4689 self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
4691 log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.context.channel_id));
4692 return Ok((Some(channel_ready), timed_out_htlcs, announcement_sigs));
4695 let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
4696 if non_shutdown_state >= ChannelState::ChannelReady as u32 ||
4697 (non_shutdown_state & ChannelState::OurChannelReady as u32) == ChannelState::OurChannelReady as u32 {
4698 let mut funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
4699 if self.context.funding_tx_confirmation_height == 0 {
4700 // Note that check_get_channel_ready may reset funding_tx_confirmation_height to
4701 // zero if it has been reorged out, however in either case, our state flags
4702 // indicate we've already sent a channel_ready
4703 funding_tx_confirmations = 0;
4706 // If we've sent channel_ready (or have both sent and received channel_ready), and
4707 // the funding transaction has become unconfirmed,
4708 // close the channel and hope we can get the latest state on chain (because presumably
4709 // the funding transaction is at least still in the mempool of most nodes).
4711 // Note that ideally we wouldn't force-close if we see *any* reorg on a 1-conf or
4712 // 0-conf channel, but not doing so may lead to the
4713 // `ChannelManager::short_to_chan_info` map being inconsistent, so we currently have
4715 if funding_tx_confirmations == 0 && self.context.funding_tx_confirmed_in.is_some() {
4716 let err_reason = format!("Funding transaction was un-confirmed. Locked at {} confs, now have {} confs.",
4717 self.context.minimum_depth.unwrap(), funding_tx_confirmations);
4718 return Err(ClosureReason::ProcessingError { err: err_reason });
4720 } else if !self.context.is_outbound() && self.context.funding_tx_confirmed_in.is_none() &&
4721 height >= self.context.channel_creation_height + FUNDING_CONF_DEADLINE_BLOCKS {
4722 log_info!(logger, "Closing channel {} due to funding timeout", log_bytes!(self.context.channel_id));
4723 // If funding_tx_confirmed_in is unset, the channel must not be active
4724 assert!(non_shutdown_state <= ChannelState::ChannelReady as u32);
4725 assert_eq!(non_shutdown_state & ChannelState::OurChannelReady as u32, 0);
4726 return Err(ClosureReason::FundingTimedOut);
4729 let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
4730 self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
4732 Ok((None, timed_out_htlcs, announcement_sigs))
4735 /// Indicates the funding transaction is no longer confirmed in the main chain. This may
4736 /// force-close the channel, but may also indicate a harmless reorganization of a block or two
4737 /// before the channel has reached channel_ready and we can just wait for more blocks.
4738 pub fn funding_transaction_unconfirmed<L: Deref>(&mut self, logger: &L) -> Result<(), ClosureReason> where L::Target: Logger {
4739 if self.context.funding_tx_confirmation_height != 0 {
4740 // We handle the funding disconnection by calling best_block_updated with a height one
4741 // below where our funding was connected, implying a reorg back to conf_height - 1.
4742 let reorg_height = self.context.funding_tx_confirmation_height - 1;
4743 // We use the time field to bump the current time we set on channel updates if its
4744 // larger. If we don't know that time has moved forward, we can just set it to the last
4745 // time we saw and it will be ignored.
4746 let best_time = self.context.update_time_counter;
4747 match self.do_best_block_updated(reorg_height, best_time, None::<(BlockHash, &&NodeSigner, &UserConfig)>, logger) {
4748 Ok((channel_ready, timed_out_htlcs, announcement_sigs)) => {
4749 assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
4750 assert!(timed_out_htlcs.is_empty(), "We can't have accepted HTLCs with a timeout before our funding confirmation?");
4751 assert!(announcement_sigs.is_none(), "We can't generate an announcement_sigs with 0 confirmations?");
4757 // We never learned about the funding confirmation anyway, just ignore
4762 // Methods to get unprompted messages to send to the remote end (or where we already returned
4763 // something in the handler for the message that prompted this message):
4765 /// Gets an UnsignedChannelAnnouncement for this channel. The channel must be publicly
4766 /// announceable and available for use (have exchanged ChannelReady messages in both
4767 /// directions). Should be used for both broadcasted announcements and in response to an
4768 /// AnnouncementSignatures message from the remote peer.
4770 /// Will only fail if we're not in a state where channel_announcement may be sent (including
4773 /// This will only return ChannelError::Ignore upon failure.
4774 fn get_channel_announcement<NS: Deref>(
4775 &self, node_signer: &NS, chain_hash: BlockHash, user_config: &UserConfig,
4776 ) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
4777 if !self.context.config.announced_channel {
4778 return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
4780 if !self.context.is_usable() {
4781 return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
4784 let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
4785 .map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
4786 let counterparty_node_id = NodeId::from_pubkey(&self.context.get_counterparty_node_id());
4787 let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();
4789 let msg = msgs::UnsignedChannelAnnouncement {
4790 features: channelmanager::provided_channel_features(&user_config),
4792 short_channel_id: self.context.get_short_channel_id().unwrap(),
4793 node_id_1: if were_node_one { node_id } else { counterparty_node_id },
4794 node_id_2: if were_node_one { counterparty_node_id } else { node_id },
4795 bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &self.context.get_holder_pubkeys().funding_pubkey } else { self.context.counterparty_funding_pubkey() }),
4796 bitcoin_key_2: NodeId::from_pubkey(if were_node_one { self.context.counterparty_funding_pubkey() } else { &self.context.get_holder_pubkeys().funding_pubkey }),
4797 excess_data: Vec::new(),
4803 fn get_announcement_sigs<NS: Deref, L: Deref>(
4804 &mut self, node_signer: &NS, genesis_block_hash: BlockHash, user_config: &UserConfig,
4805 best_block_height: u32, logger: &L
4806 ) -> Option<msgs::AnnouncementSignatures>
4808 NS::Target: NodeSigner,
4811 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
4815 if !self.context.is_usable() {
4819 if self.context.channel_state & ChannelState::PeerDisconnected as u32 != 0 {
4820 log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
4824 if self.context.announcement_sigs_state != AnnouncementSigsState::NotSent {
4828 log_trace!(logger, "Creating an announcement_signatures message for channel {}", log_bytes!(self.context.channel_id()));
4829 let announcement = match self.get_channel_announcement(node_signer, genesis_block_hash, user_config) {
4832 log_trace!(logger, "{:?}", e);
4836 let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
4838 log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
4843 let our_bitcoin_sig = match self.context.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx) {
4845 log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
4850 self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
4852 Some(msgs::AnnouncementSignatures {
4853 channel_id: self.context.channel_id(),
4854 short_channel_id: self.context.get_short_channel_id().unwrap(),
4855 node_signature: our_node_sig,
4856 bitcoin_signature: our_bitcoin_sig,
4860 /// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are
4862 fn sign_channel_announcement<NS: Deref>(
4863 &self, node_signer: &NS, announcement: msgs::UnsignedChannelAnnouncement
4864 ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
4865 if let Some((their_node_sig, their_bitcoin_sig)) = self.context.announcement_sigs {
4866 let our_node_key = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
4867 .map_err(|_| ChannelError::Ignore("Signer failed to retrieve own public key".to_owned()))?);
4868 let were_node_one = announcement.node_id_1 == our_node_key;
4870 let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
4871 .map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
4872 let our_bitcoin_sig = self.context.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx)
4873 .map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
4874 Ok(msgs::ChannelAnnouncement {
4875 node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
4876 node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
4877 bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
4878 bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
4879 contents: announcement,
4882 Err(ChannelError::Ignore("Attempted to sign channel announcement before we'd received announcement_signatures".to_string()))
4886 /// Processes an incoming announcement_signatures message, providing a fully-signed
4887 /// channel_announcement message which we can broadcast and storing our counterparty's
4888 /// signatures for later reconstruction/rebroadcast of the channel_announcement.
4889 pub fn announcement_signatures<NS: Deref>(
4890 &mut self, node_signer: &NS, chain_hash: BlockHash, best_block_height: u32,
4891 msg: &msgs::AnnouncementSignatures, user_config: &UserConfig
4892 ) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
4893 let announcement = self.get_channel_announcement(node_signer, chain_hash, user_config)?;
4895 let msghash = hash_to_message!(&Sha256d::hash(&announcement.encode()[..])[..]);
4897 if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.context.get_counterparty_node_id()).is_err() {
4898 return Err(ChannelError::Close(format!(
4899 "Bad announcement_signatures. Failed to verify node_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_node_key is {:?}",
4900 &announcement, self.context.get_counterparty_node_id())));
4902 if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.context.counterparty_funding_pubkey()).is_err() {
4903 return Err(ChannelError::Close(format!(
4904 "Bad announcement_signatures. Failed to verify bitcoin_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_bitcoin_key is ({:?})",
4905 &announcement, self.context.counterparty_funding_pubkey())));
4908 self.context.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
4909 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
4910 return Err(ChannelError::Ignore(
4911 "Got announcement_signatures prior to the required six confirmations - we may not have received a block yet that our peer has".to_owned()));
4914 self.sign_channel_announcement(node_signer, announcement)
4917 /// Gets a signed channel_announcement for this channel, if we previously received an
4918 /// announcement_signatures from our counterparty.
4919 pub fn get_signed_channel_announcement<NS: Deref>(
4920 &self, node_signer: &NS, chain_hash: BlockHash, best_block_height: u32, user_config: &UserConfig
4921 ) -> Option<msgs::ChannelAnnouncement> where NS::Target: NodeSigner {
4922 if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
4925 let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
4927 Err(_) => return None,
4929 match self.sign_channel_announcement(node_signer, announcement) {
4930 Ok(res) => Some(res),
4935 /// May panic if called on a channel that wasn't immediately-previously
4936 /// self.remove_uncommitted_htlcs_and_mark_paused()'d
4937 pub fn get_channel_reestablish<L: Deref>(&mut self, logger: &L) -> msgs::ChannelReestablish where L::Target: Logger {
4938 assert_eq!(self.context.channel_state & ChannelState::PeerDisconnected as u32, ChannelState::PeerDisconnected as u32);
4939 assert_ne!(self.context.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
4940 // Prior to static_remotekey, my_current_per_commitment_point was critical to claiming
4941 // current to_remote balances. However, it no longer has any use, and thus is now simply
4942 // set to a dummy (but valid, as required by the spec) public key.
4943 // fuzzing mode marks a subset of pubkeys as invalid so that we can hit "invalid pubkey"
4944 // branches, but we unwrap it below, so we arbitrarily select a dummy pubkey which is both
4945 // valid, and valid in fuzzing mode's arbitrary validity criteria:
4946 let mut pk = [2; 33]; pk[1] = 0xff;
4947 let dummy_pubkey = PublicKey::from_slice(&pk).unwrap();
4948 let remote_last_secret = if self.context.cur_counterparty_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
4949 let remote_last_secret = self.context.commitment_secrets.get_secret(self.context.cur_counterparty_commitment_transaction_number + 2).unwrap();
4950 log_trace!(logger, "Enough info to generate a Data Loss Protect with per_commitment_secret {} for channel {}", log_bytes!(remote_last_secret), log_bytes!(self.context.channel_id()));
4953 log_info!(logger, "Sending a data_loss_protect with no previous remote per_commitment_secret for channel {}", log_bytes!(self.context.channel_id()));
4956 self.mark_awaiting_response();
4957 msgs::ChannelReestablish {
4958 channel_id: self.context.channel_id(),
4959 // The protocol has two different commitment number concepts - the "commitment
4960 // transaction number", which starts from 0 and counts up, and the "revocation key
4961 // index" which starts at INITIAL_COMMITMENT_NUMBER and counts down. We track
4962 // commitment transaction numbers by the index which will be used to reveal the
4963 // revocation key for that commitment transaction, which means we have to convert them
4964 // to protocol-level commitment numbers here...
4966 // next_local_commitment_number is the next commitment_signed number we expect to
4967 // receive (indicating if they need to resend one that we missed).
4968 next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number,
4969 // We have to set next_remote_commitment_number to the next revoke_and_ack we expect to
4970 // receive, however we track it by the next commitment number for a remote transaction
4971 // (which is one further, as they always revoke previous commitment transaction, not
4972 // the one we send) so we have to decrement by 1. Note that if
4973 // cur_counterparty_commitment_transaction_number is INITIAL_COMMITMENT_NUMBER we will have
4974 // dropped this channel on disconnect as it hasn't yet reached FundingSent so we can't
4976 next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number - 1,
4977 your_last_per_commitment_secret: remote_last_secret,
4978 my_current_per_commitment_point: dummy_pubkey,
4979 // TODO(dual_funding): If we've sent `commtiment_signed` for an interactive transaction
4980 // construction but have not received `tx_signatures` we MUST set `next_funding_txid` to the
4981 // txid of that interactive transaction, else we MUST NOT set it.
4982 next_funding_txid: None,
4987 // Send stuff to our remote peers:
4989 /// Queues up an outbound HTLC to send by placing it in the holding cell. You should call
4990 /// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
4991 /// commitment update.
4993 /// `Err`s will only be [`ChannelError::Ignore`].
4994 pub fn queue_add_htlc<L: Deref>(
4995 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
4996 onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>, logger: &L
4997 ) -> Result<(), ChannelError> where L::Target: Logger {
4999 .send_htlc(amount_msat, payment_hash, cltv_expiry, source, onion_routing_packet, true,
5000 skimmed_fee_msat, logger)
5001 .map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
5003 if let ChannelError::Ignore(_) = err { /* fine */ }
5004 else { debug_assert!(false, "Queueing cannot trigger channel failure"); }
5009 /// Adds a pending outbound HTLC to this channel, note that you probably want
5010 /// [`Self::send_htlc_and_commit`] instead cause you'll want both messages at once.
5012 /// This returns an optional UpdateAddHTLC as we may be in a state where we cannot add HTLCs on
5014 /// * In cases where we're waiting on the remote peer to send us a revoke_and_ack, we
5015 /// wouldn't be able to determine what they actually ACK'ed if we have two sets of updates
5017 /// * In cases where we're marked MonitorUpdateInProgress, we cannot commit to a new state as
5018 /// we may not yet have sent the previous commitment update messages and will need to
5019 /// regenerate them.
5021 /// You MUST call [`Self::send_commitment_no_state_update`] prior to calling any other methods
5022 /// on this [`Channel`] if `force_holding_cell` is false.
5024 /// `Err`s will only be [`ChannelError::Ignore`].
5025 fn send_htlc<L: Deref>(
5026 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
5027 onion_routing_packet: msgs::OnionPacket, mut force_holding_cell: bool,
5028 skimmed_fee_msat: Option<u64>, logger: &L
5029 ) -> Result<Option<msgs::UpdateAddHTLC>, ChannelError> where L::Target: Logger {
5030 if (self.context.channel_state & (ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelReady as u32) {
5031 return Err(ChannelError::Ignore("Cannot send HTLC until channel is fully established and we haven't started shutting down".to_owned()));
5033 let channel_total_msat = self.context.channel_value_satoshis * 1000;
5034 if amount_msat > channel_total_msat {
5035 return Err(ChannelError::Ignore(format!("Cannot send amount {}, because it is more than the total value of the channel {}", amount_msat, channel_total_msat)));
5038 if amount_msat == 0 {
5039 return Err(ChannelError::Ignore("Cannot send 0-msat HTLC".to_owned()));
5042 let available_balances = self.context.get_available_balances();
5043 if amount_msat < available_balances.next_outbound_htlc_minimum_msat {
5044 return Err(ChannelError::Ignore(format!("Cannot send less than our next-HTLC minimum - {} msat",
5045 available_balances.next_outbound_htlc_minimum_msat)));
5048 if amount_msat > available_balances.next_outbound_htlc_limit_msat {
5049 return Err(ChannelError::Ignore(format!("Cannot send more than our next-HTLC maximum - {} msat",
5050 available_balances.next_outbound_htlc_limit_msat)));
5053 if (self.context.channel_state & (ChannelState::PeerDisconnected as u32)) != 0 {
5054 // Note that this should never really happen, if we're !is_live() on receipt of an
5055 // incoming HTLC for relay will result in us rejecting the HTLC and we won't allow
5056 // the user to send directly into a !is_live() channel. However, if we
5057 // disconnected during the time the previous hop was doing the commitment dance we may
5058 // end up getting here after the forwarding delay. In any case, returning an
5059 // IgnoreError will get ChannelManager to do the right thing and fail backwards now.
5060 return Err(ChannelError::Ignore("Cannot send an HTLC while disconnected from channel counterparty".to_owned()));
5063 let need_holding_cell = (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0;
5064 log_debug!(logger, "Pushing new outbound HTLC for {} msat {}", amount_msat,
5065 if force_holding_cell { "into holding cell" }
5066 else if need_holding_cell { "into holding cell as we're awaiting an RAA or monitor" }
5067 else { "to peer" });
5069 if need_holding_cell {
5070 force_holding_cell = true;
5073 // Now update local state:
5074 if force_holding_cell {
5075 self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
5080 onion_routing_packet,
5086 self.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
5087 htlc_id: self.context.next_holder_htlc_id,
5089 payment_hash: payment_hash.clone(),
5091 state: OutboundHTLCState::LocalAnnounced(Box::new(onion_routing_packet.clone())),
5096 let res = msgs::UpdateAddHTLC {
5097 channel_id: self.context.channel_id,
5098 htlc_id: self.context.next_holder_htlc_id,
5102 onion_routing_packet,
5105 self.context.next_holder_htlc_id += 1;
5110 fn build_commitment_no_status_check<L: Deref>(&mut self, logger: &L) -> ChannelMonitorUpdate where L::Target: Logger {
5111 log_trace!(logger, "Updating HTLC state for a newly-sent commitment_signed...");
5112 // We can upgrade the status of some HTLCs that are waiting on a commitment, even if we
5113 // fail to generate this, we still are at least at a position where upgrading their status
5115 for htlc in self.context.pending_inbound_htlcs.iter_mut() {
5116 let new_state = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref forward_info) = &htlc.state {
5117 Some(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info.clone()))
5119 if let Some(state) = new_state {
5120 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
5124 for htlc in self.context.pending_outbound_htlcs.iter_mut() {
5125 if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
5126 log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", log_bytes!(htlc.payment_hash.0));
5127 // Grab the preimage, if it exists, instead of cloning
5128 let mut reason = OutboundHTLCOutcome::Success(None);
5129 mem::swap(outcome, &mut reason);
5130 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
5133 if let Some((feerate, update_state)) = self.context.pending_update_fee {
5134 if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {
5135 debug_assert!(!self.context.is_outbound());
5136 log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
5137 self.context.feerate_per_kw = feerate;
5138 self.context.pending_update_fee = None;
5141 self.context.resend_order = RAACommitmentOrder::RevokeAndACKFirst;
5143 let (counterparty_commitment_txid, mut htlcs_ref) = self.build_commitment_no_state_update(logger);
5144 let htlcs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)> =
5145 htlcs_ref.drain(..).map(|(htlc, htlc_source)| (htlc, htlc_source.map(|source_ref| Box::new(source_ref.clone())))).collect();
5147 if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent {
5148 self.context.announcement_sigs_state = AnnouncementSigsState::Committed;
5151 self.context.latest_monitor_update_id += 1;
5152 let monitor_update = ChannelMonitorUpdate {
5153 update_id: self.context.latest_monitor_update_id,
5154 updates: vec![ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
5155 commitment_txid: counterparty_commitment_txid,
5156 htlc_outputs: htlcs.clone(),
5157 commitment_number: self.context.cur_counterparty_commitment_transaction_number,
5158 their_per_commitment_point: self.context.counterparty_cur_commitment_point.unwrap()
5161 self.context.channel_state |= ChannelState::AwaitingRemoteRevoke as u32;
5165 fn build_commitment_no_state_update<L: Deref>(&self, logger: &L) -> (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>) where L::Target: Logger {
5166 let counterparty_keys = self.context.build_remote_transaction_keys();
5167 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
5168 let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
5170 #[cfg(any(test, fuzzing))]
5172 if !self.context.is_outbound() {
5173 let projected_commit_tx_info = self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap().take();
5174 *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
5175 if let Some(info) = projected_commit_tx_info {
5176 let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
5177 if info.total_pending_htlcs == total_pending_htlcs
5178 && info.next_holder_htlc_id == self.context.next_holder_htlc_id
5179 && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
5180 && info.feerate == self.context.feerate_per_kw {
5181 let actual_fee = commit_tx_fee_msat(self.context.feerate_per_kw, commitment_stats.num_nondust_htlcs, self.context.get_channel_type());
5182 assert_eq!(actual_fee, info.fee);
5188 (counterparty_commitment_txid, commitment_stats.htlcs_included)
5191 /// Only fails in case of signer rejection. Used for channel_reestablish commitment_signed
5192 /// generation when we shouldn't change HTLC/channel state.
5193 fn send_commitment_no_state_update<L: Deref>(&self, logger: &L) -> Result<(msgs::CommitmentSigned, (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>)), ChannelError> where L::Target: Logger {
5194 // Get the fee tests from `build_commitment_no_state_update`
5195 #[cfg(any(test, fuzzing))]
5196 self.build_commitment_no_state_update(logger);
5198 let counterparty_keys = self.context.build_remote_transaction_keys();
5199 let commitment_stats = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
5200 let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
5201 let (signature, htlc_signatures);
5204 let mut htlcs = Vec::with_capacity(commitment_stats.htlcs_included.len());
5205 for &(ref htlc, _) in commitment_stats.htlcs_included.iter() {
5209 let res = self.context.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.context.secp_ctx)
5210 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
5212 htlc_signatures = res.1;
5214 log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {} in channel {}",
5215 encode::serialize_hex(&commitment_stats.tx.trust().built_transaction().transaction),
5216 &counterparty_commitment_txid, encode::serialize_hex(&self.context.get_funding_redeemscript()),
5217 log_bytes!(signature.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
5219 for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(htlcs) {
5220 log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {} in channel {}",
5221 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)),
5222 encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, &self.context.channel_type, &counterparty_keys)),
5223 log_bytes!(counterparty_keys.broadcaster_htlc_key.serialize()),
5224 log_bytes!(htlc_sig.serialize_compact()[..]), log_bytes!(self.context.channel_id()));
5228 Ok((msgs::CommitmentSigned {
5229 channel_id: self.context.channel_id,
5233 partial_signature_with_nonce: None,
5234 }, (counterparty_commitment_txid, commitment_stats.htlcs_included)))
5237 /// Adds a pending outbound HTLC to this channel, and builds a new remote commitment
5238 /// transaction and generates the corresponding [`ChannelMonitorUpdate`] in one go.
5240 /// Shorthand for calling [`Self::send_htlc`] followed by a commitment update, see docs on
5241 /// [`Self::send_htlc`] and [`Self::build_commitment_no_state_update`] for more info.
5242 pub fn send_htlc_and_commit<L: Deref>(
5243 &mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
5244 onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>, logger: &L
5245 ) -> Result<Option<ChannelMonitorUpdate>, ChannelError> where L::Target: Logger {
5246 let send_res = self.send_htlc(amount_msat, payment_hash, cltv_expiry, source,
5247 onion_routing_packet, false, skimmed_fee_msat, logger);
5248 if let Err(e) = &send_res { if let ChannelError::Ignore(_) = e {} else { debug_assert!(false, "Sending cannot trigger channel failure"); } }
5251 let monitor_update = self.build_commitment_no_status_check(logger);
5252 self.monitor_updating_paused(false, true, false, Vec::new(), Vec::new(), Vec::new());
5253 Ok(self.push_ret_blockable_mon_update(monitor_update))
5259 pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<(), ChannelError> {
5260 if msg.contents.htlc_minimum_msat >= self.context.channel_value_satoshis * 1000 {
5261 return Err(ChannelError::Close("Minimum htlc value is greater than channel value".to_string()));
5263 self.context.counterparty_forwarding_info = Some(CounterpartyForwardingInfo {
5264 fee_base_msat: msg.contents.fee_base_msat,
5265 fee_proportional_millionths: msg.contents.fee_proportional_millionths,
5266 cltv_expiry_delta: msg.contents.cltv_expiry_delta
5272 /// Begins the shutdown process, getting a message for the remote peer and returning all
5273 /// holding cell HTLCs for payment failure.
5275 /// May jump to the channel being fully shutdown (see [`Self::is_shutdown`]) in which case no
5276 /// [`ChannelMonitorUpdate`] will be returned).
5277 pub fn get_shutdown<SP: Deref>(&mut self, signer_provider: &SP, their_features: &InitFeatures,
5278 target_feerate_sats_per_kw: Option<u32>, override_shutdown_script: Option<ShutdownScript>)
5279 -> Result<(msgs::Shutdown, Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), APIError>
5280 where SP::Target: SignerProvider {
5281 for htlc in self.context.pending_outbound_htlcs.iter() {
5282 if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
5283 return Err(APIError::APIMisuseError{err: "Cannot begin shutdown with pending HTLCs. Process pending events first".to_owned()});
5286 if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK != 0 {
5287 if (self.context.channel_state & ChannelState::LocalShutdownSent as u32) == ChannelState::LocalShutdownSent as u32 {
5288 return Err(APIError::APIMisuseError{err: "Shutdown already in progress".to_owned()});
5290 else if (self.context.channel_state & ChannelState::RemoteShutdownSent as u32) == ChannelState::RemoteShutdownSent as u32 {
5291 return Err(APIError::ChannelUnavailable{err: "Shutdown already in progress by remote".to_owned()});
5294 if self.context.shutdown_scriptpubkey.is_some() && override_shutdown_script.is_some() {
5295 return Err(APIError::APIMisuseError{err: "Cannot override shutdown script for a channel with one already set".to_owned()});
5297 assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
5298 if self.context.channel_state & (ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0 {
5299 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()});
5302 // If we haven't funded the channel yet, we don't need to bother ensuring the shutdown
5303 // script is set, we just force-close and call it a day.
5304 let mut chan_closed = false;
5305 if self.context.channel_state < ChannelState::FundingSent as u32 {
5309 let update_shutdown_script = match self.context.shutdown_scriptpubkey {
5311 None if !chan_closed => {
5312 // use override shutdown script if provided
5313 let shutdown_scriptpubkey = match override_shutdown_script {
5314 Some(script) => script,
5316 // otherwise, use the shutdown scriptpubkey provided by the signer
5317 match signer_provider.get_shutdown_scriptpubkey() {
5318 Ok(scriptpubkey) => scriptpubkey,
5319 Err(_) => return Err(APIError::ChannelUnavailable{err: "Failed to get shutdown scriptpubkey".to_owned()}),
5323 if !shutdown_scriptpubkey.is_compatible(their_features) {
5324 return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
5326 self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
5332 // From here on out, we may not fail!
5333 self.context.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
5334 if self.context.channel_state < ChannelState::FundingSent as u32 {
5335 self.context.channel_state = ChannelState::ShutdownComplete as u32;
5337 self.context.channel_state |= ChannelState::LocalShutdownSent as u32;
5339 self.context.update_time_counter += 1;
5341 let monitor_update = if update_shutdown_script {
5342 self.context.latest_monitor_update_id += 1;
5343 let monitor_update = ChannelMonitorUpdate {
5344 update_id: self.context.latest_monitor_update_id,
5345 updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
5346 scriptpubkey: self.get_closing_scriptpubkey(),
5349 self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
5350 self.push_ret_blockable_mon_update(monitor_update)
5352 let shutdown = msgs::Shutdown {
5353 channel_id: self.context.channel_id,
5354 scriptpubkey: self.get_closing_scriptpubkey(),
5357 // Go ahead and drop holding cell updates as we'd rather fail payments than wait to send
5358 // our shutdown until we've committed all of the pending changes.
5359 self.context.holding_cell_update_fee = None;
5360 let mut dropped_outbound_htlcs = Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
5361 self.context.holding_cell_htlc_updates.retain(|htlc_update| {
5363 &HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
5364 dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
5371 debug_assert!(!self.is_shutdown() || monitor_update.is_none(),
5372 "we can't both complete shutdown and return a monitor update");
5374 Ok((shutdown, monitor_update, dropped_outbound_htlcs))
5377 pub fn inflight_htlc_sources(&self) -> impl Iterator<Item=(&HTLCSource, &PaymentHash)> {
5378 self.context.holding_cell_htlc_updates.iter()
5379 .flat_map(|htlc_update| {
5381 HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. }
5382 => Some((source, payment_hash)),
5386 .chain(self.context.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
5390 /// A not-yet-funded outbound (from holder) channel using V1 channel establishment.
5391 pub(super) struct OutboundV1Channel<Signer: ChannelSigner> {
5392 pub context: ChannelContext<Signer>,
5395 impl<Signer: WriteableEcdsaChannelSigner> OutboundV1Channel<Signer> {
5396 pub fn new<ES: Deref, SP: Deref, F: Deref>(
5397 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP, counterparty_node_id: PublicKey, their_features: &InitFeatures,
5398 channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig, current_chain_height: u32,
5399 outbound_scid_alias: u64
5400 ) -> Result<OutboundV1Channel<Signer>, APIError>
5401 where ES::Target: EntropySource,
5402 SP::Target: SignerProvider<Signer = Signer>,
5403 F::Target: FeeEstimator,
5405 let holder_selected_contest_delay = config.channel_handshake_config.our_to_self_delay;
5406 let channel_keys_id = signer_provider.generate_channel_keys_id(false, channel_value_satoshis, user_id);
5407 let holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
5408 let pubkeys = holder_signer.pubkeys().clone();
5410 if !their_features.supports_wumbo() && channel_value_satoshis > MAX_FUNDING_SATOSHIS_NO_WUMBO {
5411 return Err(APIError::APIMisuseError{err: format!("funding_value must not exceed {}, it was {}", MAX_FUNDING_SATOSHIS_NO_WUMBO, channel_value_satoshis)});
5413 if channel_value_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
5414 return Err(APIError::APIMisuseError{err: format!("funding_value must be smaller than the total bitcoin supply, it was {}", channel_value_satoshis)});
5416 let channel_value_msat = channel_value_satoshis * 1000;
5417 if push_msat > channel_value_msat {
5418 return Err(APIError::APIMisuseError { err: format!("Push value ({}) was larger than channel_value ({})", push_msat, channel_value_msat) });
5420 if holder_selected_contest_delay < BREAKDOWN_TIMEOUT {
5421 return Err(APIError::APIMisuseError {err: format!("Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks", holder_selected_contest_delay)});
5423 let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(channel_value_satoshis, config);
5424 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
5425 // Protocol level safety check in place, although it should never happen because
5426 // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
5427 return Err(APIError::APIMisuseError { err: format!("Holder selected channel reserve below implemention limit dust_limit_satoshis {}", holder_selected_channel_reserve_satoshis) });
5430 let channel_type = Self::get_initial_channel_type(&config, their_features);
5431 debug_assert!(channel_type.is_subset(&channelmanager::provided_channel_type_features(&config)));
5433 let feerate = fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::Normal);
5435 let value_to_self_msat = channel_value_satoshis * 1000 - push_msat;
5436 let commitment_tx_fee = commit_tx_fee_msat(feerate, MIN_AFFORDABLE_HTLC_COUNT, &channel_type);
5437 if value_to_self_msat < commitment_tx_fee {
5438 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) });
5441 let mut secp_ctx = Secp256k1::new();
5442 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
5444 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
5445 match signer_provider.get_shutdown_scriptpubkey() {
5446 Ok(scriptpubkey) => Some(scriptpubkey),
5447 Err(_) => return Err(APIError::ChannelUnavailable { err: "Failed to get shutdown scriptpubkey".to_owned()}),
5451 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
5452 if !shutdown_scriptpubkey.is_compatible(&their_features) {
5453 return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
5457 let destination_script = match signer_provider.get_destination_script() {
5458 Ok(script) => script,
5459 Err(_) => return Err(APIError::ChannelUnavailable { err: "Failed to get destination script".to_owned()}),
5462 let temporary_channel_id = entropy_source.get_secure_random_bytes();
5465 context: ChannelContext {
5468 config: LegacyChannelConfig {
5469 options: config.channel_config.clone(),
5470 announced_channel: config.channel_handshake_config.announced_channel,
5471 commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
5476 inbound_handshake_limits_override: Some(config.channel_handshake_limits.clone()),
5478 channel_id: temporary_channel_id,
5479 temporary_channel_id: Some(temporary_channel_id),
5480 channel_state: ChannelState::OurInitSent as u32,
5481 announcement_sigs_state: AnnouncementSigsState::NotSent,
5483 channel_value_satoshis,
5485 latest_monitor_update_id: 0,
5488 shutdown_scriptpubkey,
5491 cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
5492 cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
5495 pending_inbound_htlcs: Vec::new(),
5496 pending_outbound_htlcs: Vec::new(),
5497 holding_cell_htlc_updates: Vec::new(),
5498 pending_update_fee: None,
5499 holding_cell_update_fee: None,
5500 next_holder_htlc_id: 0,
5501 next_counterparty_htlc_id: 0,
5502 update_time_counter: 1,
5504 resend_order: RAACommitmentOrder::CommitmentFirst,
5506 monitor_pending_channel_ready: false,
5507 monitor_pending_revoke_and_ack: false,
5508 monitor_pending_commitment_signed: false,
5509 monitor_pending_forwards: Vec::new(),
5510 monitor_pending_failures: Vec::new(),
5511 monitor_pending_finalized_fulfills: Vec::new(),
5513 #[cfg(debug_assertions)]
5514 holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
5515 #[cfg(debug_assertions)]
5516 counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
5518 last_sent_closing_fee: None,
5519 pending_counterparty_closing_signed: None,
5520 closing_fee_limits: None,
5521 target_closing_feerate_sats_per_kw: None,
5523 inbound_awaiting_accept: false,
5525 funding_tx_confirmed_in: None,
5526 funding_tx_confirmation_height: 0,
5527 short_channel_id: None,
5528 channel_creation_height: current_chain_height,
5530 feerate_per_kw: feerate,
5531 counterparty_dust_limit_satoshis: 0,
5532 holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
5533 counterparty_max_htlc_value_in_flight_msat: 0,
5534 holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &config.channel_handshake_config),
5535 counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
5536 holder_selected_channel_reserve_satoshis,
5537 counterparty_htlc_minimum_msat: 0,
5538 holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
5539 counterparty_max_accepted_htlcs: 0,
5540 holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
5541 minimum_depth: None, // Filled in in accept_channel
5543 counterparty_forwarding_info: None,
5545 channel_transaction_parameters: ChannelTransactionParameters {
5546 holder_pubkeys: pubkeys,
5547 holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
5548 is_outbound_from_holder: true,
5549 counterparty_parameters: None,
5550 funding_outpoint: None,
5551 channel_type_features: channel_type.clone()
5553 funding_transaction: None,
5555 counterparty_cur_commitment_point: None,
5556 counterparty_prev_commitment_point: None,
5557 counterparty_node_id,
5559 counterparty_shutdown_scriptpubkey: None,
5561 commitment_secrets: CounterpartyCommitmentSecrets::new(),
5563 channel_update_status: ChannelUpdateStatus::Enabled,
5564 closing_signed_in_flight: false,
5566 announcement_sigs: None,
5568 #[cfg(any(test, fuzzing))]
5569 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
5570 #[cfg(any(test, fuzzing))]
5571 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
5573 workaround_lnd_bug_4006: None,
5574 sent_message_awaiting_response: None,
5576 latest_inbound_scid_alias: None,
5577 outbound_scid_alias,
5579 channel_pending_event_emitted: false,
5580 channel_ready_event_emitted: false,
5582 #[cfg(any(test, fuzzing))]
5583 historical_inbound_htlc_fulfills: HashSet::new(),
5588 blocked_monitor_updates: Vec::new(),
5593 /// If an Err is returned, it is a ChannelError::Close (for get_outbound_funding_created)
5594 fn get_outbound_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
5595 let counterparty_keys = self.context.build_remote_transaction_keys();
5596 let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
5597 Ok(self.context.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
5598 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
5601 /// Updates channel state with knowledge of the funding transaction's txid/index, and generates
5602 /// a funding_created message for the remote peer.
5603 /// Panics if called at some time other than immediately after initial handshake, if called twice,
5604 /// or if called on an inbound channel.
5605 /// Note that channel_id changes during this call!
5606 /// Do NOT broadcast the funding transaction until after a successful funding_signed call!
5607 /// If an Err is returned, it is a ChannelError::Close.
5608 pub fn get_outbound_funding_created<L: Deref>(mut self, funding_transaction: Transaction, funding_txo: OutPoint, logger: &L)
5609 -> Result<(Channel<Signer>, msgs::FundingCreated), (Self, ChannelError)> where L::Target: Logger {
5610 if !self.context.is_outbound() {
5611 panic!("Tried to create outbound funding_created message on an inbound channel!");
5613 if self.context.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
5614 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)");
5616 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
5617 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
5618 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
5619 panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
5622 self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
5623 self.context.holder_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
5625 let signature = match self.get_outbound_funding_created_signature(logger) {
5628 log_error!(logger, "Got bad signatures: {:?}!", e);
5629 self.context.channel_transaction_parameters.funding_outpoint = None;
5630 return Err((self, e));
5634 let temporary_channel_id = self.context.channel_id;
5636 // Now that we're past error-generating stuff, update our local state:
5638 self.context.channel_state = ChannelState::FundingCreated as u32;
5639 self.context.channel_id = funding_txo.to_channel_id();
5640 self.context.funding_transaction = Some(funding_transaction);
5642 let channel = Channel {
5643 context: self.context,
5646 Ok((channel, msgs::FundingCreated {
5647 temporary_channel_id,
5648 funding_txid: funding_txo.txid,
5649 funding_output_index: funding_txo.index,
5652 partial_signature_with_nonce: None,
5654 next_local_nonce: None,
5658 fn get_initial_channel_type(config: &UserConfig, their_features: &InitFeatures) -> ChannelTypeFeatures {
5659 // The default channel type (ie the first one we try) depends on whether the channel is
5660 // public - if it is, we just go with `only_static_remotekey` as it's the only option
5661 // available. If it's private, we first try `scid_privacy` as it provides better privacy
5662 // with no other changes, and fall back to `only_static_remotekey`.
5663 let mut ret = ChannelTypeFeatures::only_static_remote_key();
5664 if !config.channel_handshake_config.announced_channel &&
5665 config.channel_handshake_config.negotiate_scid_privacy &&
5666 their_features.supports_scid_privacy() {
5667 ret.set_scid_privacy_required();
5670 // Optionally, if the user would like to negotiate the `anchors_zero_fee_htlc_tx` option, we
5671 // set it now. If they don't understand it, we'll fall back to our default of
5672 // `only_static_remotekey`.
5673 if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx &&
5674 their_features.supports_anchors_zero_fee_htlc_tx() {
5675 ret.set_anchors_zero_fee_htlc_tx_required();
5681 /// If we receive an error message, it may only be a rejection of the channel type we tried,
5682 /// not of our ability to open any channel at all. Thus, on error, we should first call this
5683 /// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
5684 pub(crate) fn maybe_handle_error_without_close(&mut self, chain_hash: BlockHash) -> Result<msgs::OpenChannel, ()> {
5685 if !self.context.is_outbound() || self.context.channel_state != ChannelState::OurInitSent as u32 { return Err(()); }
5686 if self.context.channel_type == ChannelTypeFeatures::only_static_remote_key() {
5687 // We've exhausted our options
5690 // We support opening a few different types of channels. Try removing our additional
5691 // features one by one until we've either arrived at our default or the counterparty has
5694 // Due to the order below, we may not negotiate `option_anchors_zero_fee_htlc_tx` if the
5695 // counterparty doesn't support `option_scid_privacy`. Since `get_initial_channel_type`
5696 // checks whether the counterparty supports every feature, this would only happen if the
5697 // counterparty is advertising the feature, but rejecting channels proposing the feature for
5699 if self.context.channel_type.supports_anchors_zero_fee_htlc_tx() {
5700 self.context.channel_type.clear_anchors_zero_fee_htlc_tx();
5701 assert!(!self.context.channel_transaction_parameters.channel_type_features.supports_anchors_nonzero_fee_htlc_tx());
5702 } else if self.context.channel_type.supports_scid_privacy() {
5703 self.context.channel_type.clear_scid_privacy();
5705 self.context.channel_type = ChannelTypeFeatures::only_static_remote_key();
5707 self.context.channel_transaction_parameters.channel_type_features = self.context.channel_type.clone();
5708 Ok(self.get_open_channel(chain_hash))
5711 pub fn get_open_channel(&self, chain_hash: BlockHash) -> msgs::OpenChannel {
5712 if !self.context.is_outbound() {
5713 panic!("Tried to open a channel for an inbound channel?");
5715 if self.context.channel_state != ChannelState::OurInitSent as u32 {
5716 panic!("Cannot generate an open_channel after we've moved forward");
5719 if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
5720 panic!("Tried to send an open_channel for a channel that has already advanced");
5723 let first_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
5724 let keys = self.context.get_holder_pubkeys();
5728 temporary_channel_id: self.context.channel_id,
5729 funding_satoshis: self.context.channel_value_satoshis,
5730 push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
5731 dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
5732 max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
5733 channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
5734 htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
5735 feerate_per_kw: self.context.feerate_per_kw as u32,
5736 to_self_delay: self.context.get_holder_selected_contest_delay(),
5737 max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
5738 funding_pubkey: keys.funding_pubkey,
5739 revocation_basepoint: keys.revocation_basepoint,
5740 payment_point: keys.payment_point,
5741 delayed_payment_basepoint: keys.delayed_payment_basepoint,
5742 htlc_basepoint: keys.htlc_basepoint,
5743 first_per_commitment_point,
5744 channel_flags: if self.context.config.announced_channel {1} else {0},
5745 shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
5746 Some(script) => script.clone().into_inner(),
5747 None => Builder::new().into_script(),
5749 channel_type: Some(self.context.channel_type.clone()),
5754 pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, default_limits: &ChannelHandshakeLimits, their_features: &InitFeatures) -> Result<(), ChannelError> {
5755 let peer_limits = if let Some(ref limits) = self.context.inbound_handshake_limits_override { limits } else { default_limits };
5757 // Check sanity of message fields:
5758 if !self.context.is_outbound() {
5759 return Err(ChannelError::Close("Got an accept_channel message from an inbound peer".to_owned()));
5761 if self.context.channel_state != ChannelState::OurInitSent as u32 {
5762 return Err(ChannelError::Close("Got an accept_channel message at a strange time".to_owned()));
5764 if msg.dust_limit_satoshis > 21000000 * 100000000 {
5765 return Err(ChannelError::Close(format!("Peer never wants payout outputs? dust_limit_satoshis was {}", msg.dust_limit_satoshis)));
5767 if msg.channel_reserve_satoshis > self.context.channel_value_satoshis {
5768 return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.context.channel_value_satoshis)));
5770 if msg.dust_limit_satoshis > self.context.holder_selected_channel_reserve_satoshis {
5771 return Err(ChannelError::Close(format!("Dust limit ({}) is bigger than our channel reserve ({})", msg.dust_limit_satoshis, self.context.holder_selected_channel_reserve_satoshis)));
5773 if msg.channel_reserve_satoshis > self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis {
5774 return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than channel value minus our reserve ({})",
5775 msg.channel_reserve_satoshis, self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis)));
5777 let full_channel_value_msat = (self.context.channel_value_satoshis - msg.channel_reserve_satoshis) * 1000;
5778 if msg.htlc_minimum_msat >= full_channel_value_msat {
5779 return Err(ChannelError::Close(format!("Minimum htlc value ({}) is full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
5781 let max_delay_acceptable = u16::min(peer_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
5782 if msg.to_self_delay > max_delay_acceptable {
5783 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)));
5785 if msg.max_accepted_htlcs < 1 {
5786 return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
5788 if msg.max_accepted_htlcs > MAX_HTLCS {
5789 return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
5792 // Now check against optional parameters as set by config...
5793 if msg.htlc_minimum_msat > peer_limits.max_htlc_minimum_msat {
5794 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)));
5796 if msg.max_htlc_value_in_flight_msat < peer_limits.min_max_htlc_value_in_flight_msat {
5797 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)));
5799 if msg.channel_reserve_satoshis > peer_limits.max_channel_reserve_satoshis {
5800 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)));
5802 if msg.max_accepted_htlcs < peer_limits.min_max_accepted_htlcs {
5803 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)));
5805 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
5806 return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
5808 if msg.dust_limit_satoshis > MAX_CHAN_DUST_LIMIT_SATOSHIS {
5809 return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
5811 if msg.minimum_depth > peer_limits.max_minimum_depth {
5812 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)));
5815 if let Some(ty) = &msg.channel_type {
5816 if *ty != self.context.channel_type {
5817 return Err(ChannelError::Close("Channel Type in accept_channel didn't match the one sent in open_channel.".to_owned()));
5819 } else if their_features.supports_channel_type() {
5820 // Assume they've accepted the channel type as they said they understand it.
5822 let channel_type = ChannelTypeFeatures::from_init(&their_features);
5823 if channel_type != ChannelTypeFeatures::only_static_remote_key() {
5824 return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
5826 self.context.channel_type = channel_type.clone();
5827 self.context.channel_transaction_parameters.channel_type_features = channel_type;
5830 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
5831 match &msg.shutdown_scriptpubkey {
5832 &Some(ref script) => {
5833 // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
5834 if script.len() == 0 {
5837 if !script::is_bolt2_compliant(&script, their_features) {
5838 return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)));
5840 Some(script.clone())
5843 // 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
5845 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()));
5850 self.context.counterparty_dust_limit_satoshis = msg.dust_limit_satoshis;
5851 self.context.counterparty_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.context.channel_value_satoshis * 1000);
5852 self.context.counterparty_selected_channel_reserve_satoshis = Some(msg.channel_reserve_satoshis);
5853 self.context.counterparty_htlc_minimum_msat = msg.htlc_minimum_msat;
5854 self.context.counterparty_max_accepted_htlcs = msg.max_accepted_htlcs;
5856 if peer_limits.trust_own_funding_0conf {
5857 self.context.minimum_depth = Some(msg.minimum_depth);
5859 self.context.minimum_depth = Some(cmp::max(1, msg.minimum_depth));
5862 let counterparty_pubkeys = ChannelPublicKeys {
5863 funding_pubkey: msg.funding_pubkey,
5864 revocation_basepoint: msg.revocation_basepoint,
5865 payment_point: msg.payment_point,
5866 delayed_payment_basepoint: msg.delayed_payment_basepoint,
5867 htlc_basepoint: msg.htlc_basepoint
5870 self.context.channel_transaction_parameters.counterparty_parameters = Some(CounterpartyChannelTransactionParameters {
5871 selected_contest_delay: msg.to_self_delay,
5872 pubkeys: counterparty_pubkeys,
5875 self.context.counterparty_cur_commitment_point = Some(msg.first_per_commitment_point);
5876 self.context.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;
5878 self.context.channel_state = ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32;
5879 self.context.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.
5885 /// A not-yet-funded inbound (from counterparty) channel using V1 channel establishment.
5886 pub(super) struct InboundV1Channel<Signer: ChannelSigner> {
5887 pub context: ChannelContext<Signer>,
5890 impl<Signer: WriteableEcdsaChannelSigner> InboundV1Channel<Signer> {
5891 /// Creates a new channel from a remote sides' request for one.
5892 /// Assumes chain_hash has already been checked and corresponds with what we expect!
5893 pub fn new<ES: Deref, SP: Deref, F: Deref, L: Deref>(
5894 fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
5895 counterparty_node_id: PublicKey, our_supported_features: &ChannelTypeFeatures,
5896 their_features: &InitFeatures, msg: &msgs::OpenChannel, user_id: u128, config: &UserConfig,
5897 current_chain_height: u32, logger: &L, outbound_scid_alias: u64
5898 ) -> Result<InboundV1Channel<Signer>, ChannelError>
5899 where ES::Target: EntropySource,
5900 SP::Target: SignerProvider<Signer = Signer>,
5901 F::Target: FeeEstimator,
5904 let announced_channel = if (msg.channel_flags & 1) == 1 { true } else { false };
5906 // First check the channel type is known, failing before we do anything else if we don't
5907 // support this channel type.
5908 let channel_type = if let Some(channel_type) = &msg.channel_type {
5909 if channel_type.supports_any_optional_bits() {
5910 return Err(ChannelError::Close("Channel Type field contained optional bits - this is not allowed".to_owned()));
5913 // We only support the channel types defined by the `ChannelManager` in
5914 // `provided_channel_type_features`. The channel type must always support
5915 // `static_remote_key`.
5916 if !channel_type.requires_static_remote_key() {
5917 return Err(ChannelError::Close("Channel Type was not understood - we require static remote key".to_owned()));
5919 // Make sure we support all of the features behind the channel type.
5920 if !channel_type.is_subset(our_supported_features) {
5921 return Err(ChannelError::Close("Channel Type contains unsupported features".to_owned()));
5923 if channel_type.requires_scid_privacy() && announced_channel {
5924 return Err(ChannelError::Close("SCID Alias/Privacy Channel Type cannot be set on a public channel".to_owned()));
5926 channel_type.clone()
5928 let channel_type = ChannelTypeFeatures::from_init(&their_features);
5929 if channel_type != ChannelTypeFeatures::only_static_remote_key() {
5930 return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
5935 let channel_keys_id = signer_provider.generate_channel_keys_id(true, msg.funding_satoshis, user_id);
5936 let holder_signer = signer_provider.derive_channel_signer(msg.funding_satoshis, channel_keys_id);
5937 let pubkeys = holder_signer.pubkeys().clone();
5938 let counterparty_pubkeys = ChannelPublicKeys {
5939 funding_pubkey: msg.funding_pubkey,
5940 revocation_basepoint: msg.revocation_basepoint,
5941 payment_point: msg.payment_point,
5942 delayed_payment_basepoint: msg.delayed_payment_basepoint,
5943 htlc_basepoint: msg.htlc_basepoint
5946 if config.channel_handshake_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
5947 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)));
5950 // Check sanity of message fields:
5951 if msg.funding_satoshis > config.channel_handshake_limits.max_funding_satoshis {
5952 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)));
5954 if msg.funding_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
5955 return Err(ChannelError::Close(format!("Funding must be smaller than the total bitcoin supply. It was {}", msg.funding_satoshis)));
5957 if msg.channel_reserve_satoshis > msg.funding_satoshis {
5958 return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must be not greater than funding_satoshis: {}", msg.channel_reserve_satoshis, msg.funding_satoshis)));
5960 let full_channel_value_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000;
5961 if msg.push_msat > full_channel_value_msat {
5962 return Err(ChannelError::Close(format!("push_msat {} was larger than channel amount minus reserve ({})", msg.push_msat, full_channel_value_msat)));
5964 if msg.dust_limit_satoshis > msg.funding_satoshis {
5965 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)));
5967 if msg.htlc_minimum_msat >= full_channel_value_msat {
5968 return Err(ChannelError::Close(format!("Minimum htlc value ({}) was larger than full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
5970 Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, None, logger)?;
5972 let max_counterparty_selected_contest_delay = u16::min(config.channel_handshake_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
5973 if msg.to_self_delay > max_counterparty_selected_contest_delay {
5974 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)));
5976 if msg.max_accepted_htlcs < 1 {
5977 return Err(ChannelError::Close("0 max_accepted_htlcs makes for a useless channel".to_owned()));
5979 if msg.max_accepted_htlcs > MAX_HTLCS {
5980 return Err(ChannelError::Close(format!("max_accepted_htlcs was {}. It must not be larger than {}", msg.max_accepted_htlcs, MAX_HTLCS)));
5983 // Now check against optional parameters as set by config...
5984 if msg.funding_satoshis < config.channel_handshake_limits.min_funding_satoshis {
5985 return Err(ChannelError::Close(format!("Funding satoshis ({}) is less than the user specified limit ({})", msg.funding_satoshis, config.channel_handshake_limits.min_funding_satoshis)));
5987 if msg.htlc_minimum_msat > config.channel_handshake_limits.max_htlc_minimum_msat {
5988 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)));
5990 if msg.max_htlc_value_in_flight_msat < config.channel_handshake_limits.min_max_htlc_value_in_flight_msat {
5991 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)));
5993 if msg.channel_reserve_satoshis > config.channel_handshake_limits.max_channel_reserve_satoshis {
5994 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)));
5996 if msg.max_accepted_htlcs < config.channel_handshake_limits.min_max_accepted_htlcs {
5997 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)));
5999 if msg.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
6000 return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is less than the implementation limit ({})", msg.dust_limit_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS)));
6002 if msg.dust_limit_satoshis > MAX_CHAN_DUST_LIMIT_SATOSHIS {
6003 return Err(ChannelError::Close(format!("dust_limit_satoshis ({}) is greater than the implementation limit ({})", msg.dust_limit_satoshis, MAX_CHAN_DUST_LIMIT_SATOSHIS)));
6006 // Convert things into internal flags and prep our state:
6008 if config.channel_handshake_limits.force_announced_channel_preference {
6009 if config.channel_handshake_config.announced_channel != announced_channel {
6010 return Err(ChannelError::Close("Peer tried to open channel but their announcement preference is different from ours".to_owned()));
6014 let holder_selected_channel_reserve_satoshis = get_holder_selected_channel_reserve_satoshis(msg.funding_satoshis, config);
6015 if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
6016 // Protocol level safety check in place, although it should never happen because
6017 // of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
6018 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)));
6020 if holder_selected_channel_reserve_satoshis * 1000 >= full_channel_value_msat {
6021 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)));
6023 if msg.channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
6024 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.",
6025 msg.channel_reserve_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS);
6027 if holder_selected_channel_reserve_satoshis < msg.dust_limit_satoshis {
6028 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)));
6031 // check if the funder's amount for the initial commitment tx is sufficient
6032 // for full fee payment plus a few HTLCs to ensure the channel will be useful.
6033 let funders_amount_msat = msg.funding_satoshis * 1000 - msg.push_msat;
6034 let commitment_tx_fee = commit_tx_fee_msat(msg.feerate_per_kw, MIN_AFFORDABLE_HTLC_COUNT, &channel_type) / 1000;
6035 if funders_amount_msat / 1000 < commitment_tx_fee {
6036 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)));
6039 let to_remote_satoshis = funders_amount_msat / 1000 - commitment_tx_fee;
6040 // While it's reasonable for us to not meet the channel reserve initially (if they don't
6041 // want to push much to us), our counterparty should always have more than our reserve.
6042 if to_remote_satoshis < holder_selected_channel_reserve_satoshis {
6043 return Err(ChannelError::Close("Insufficient funding amount for initial reserve".to_owned()));
6046 let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
6047 match &msg.shutdown_scriptpubkey {
6048 &Some(ref script) => {
6049 // Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
6050 if script.len() == 0 {
6053 if !script::is_bolt2_compliant(&script, their_features) {
6054 return Err(ChannelError::Close(format!("Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {}", script)))
6056 Some(script.clone())
6059 // 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
6061 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()));
6066 let shutdown_scriptpubkey = if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
6067 match signer_provider.get_shutdown_scriptpubkey() {
6068 Ok(scriptpubkey) => Some(scriptpubkey),
6069 Err(_) => return Err(ChannelError::Close("Failed to get upfront shutdown scriptpubkey".to_owned())),
6073 if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
6074 if !shutdown_scriptpubkey.is_compatible(&their_features) {
6075 return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
6079 let destination_script = match signer_provider.get_destination_script() {
6080 Ok(script) => script,
6081 Err(_) => return Err(ChannelError::Close("Failed to get destination script".to_owned())),
6084 let mut secp_ctx = Secp256k1::new();
6085 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
6088 context: ChannelContext {
6091 config: LegacyChannelConfig {
6092 options: config.channel_config.clone(),
6094 commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
6099 inbound_handshake_limits_override: None,
6101 temporary_channel_id: Some(msg.temporary_channel_id),
6102 channel_id: msg.temporary_channel_id,
6103 channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
6104 announcement_sigs_state: AnnouncementSigsState::NotSent,
6107 latest_monitor_update_id: 0,
6110 shutdown_scriptpubkey,
6113 cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
6114 cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
6115 value_to_self_msat: msg.push_msat,
6117 pending_inbound_htlcs: Vec::new(),
6118 pending_outbound_htlcs: Vec::new(),
6119 holding_cell_htlc_updates: Vec::new(),
6120 pending_update_fee: None,
6121 holding_cell_update_fee: None,
6122 next_holder_htlc_id: 0,
6123 next_counterparty_htlc_id: 0,
6124 update_time_counter: 1,
6126 resend_order: RAACommitmentOrder::CommitmentFirst,
6128 monitor_pending_channel_ready: false,
6129 monitor_pending_revoke_and_ack: false,
6130 monitor_pending_commitment_signed: false,
6131 monitor_pending_forwards: Vec::new(),
6132 monitor_pending_failures: Vec::new(),
6133 monitor_pending_finalized_fulfills: Vec::new(),
6135 #[cfg(debug_assertions)]
6136 holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
6137 #[cfg(debug_assertions)]
6138 counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
6140 last_sent_closing_fee: None,
6141 pending_counterparty_closing_signed: None,
6142 closing_fee_limits: None,
6143 target_closing_feerate_sats_per_kw: None,
6145 inbound_awaiting_accept: true,
6147 funding_tx_confirmed_in: None,
6148 funding_tx_confirmation_height: 0,
6149 short_channel_id: None,
6150 channel_creation_height: current_chain_height,
6152 feerate_per_kw: msg.feerate_per_kw,
6153 channel_value_satoshis: msg.funding_satoshis,
6154 counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
6155 holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
6156 counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
6157 holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(msg.funding_satoshis, &config.channel_handshake_config),
6158 counterparty_selected_channel_reserve_satoshis: Some(msg.channel_reserve_satoshis),
6159 holder_selected_channel_reserve_satoshis,
6160 counterparty_htlc_minimum_msat: msg.htlc_minimum_msat,
6161 holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0 { 1 } else { config.channel_handshake_config.our_htlc_minimum_msat },
6162 counterparty_max_accepted_htlcs: msg.max_accepted_htlcs,
6163 holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
6164 minimum_depth: Some(cmp::max(config.channel_handshake_config.minimum_depth, 1)),
6166 counterparty_forwarding_info: None,
6168 channel_transaction_parameters: ChannelTransactionParameters {
6169 holder_pubkeys: pubkeys,
6170 holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
6171 is_outbound_from_holder: false,
6172 counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
6173 selected_contest_delay: msg.to_self_delay,
6174 pubkeys: counterparty_pubkeys,
6176 funding_outpoint: None,
6177 channel_type_features: channel_type.clone()
6179 funding_transaction: None,
6181 counterparty_cur_commitment_point: Some(msg.first_per_commitment_point),
6182 counterparty_prev_commitment_point: None,
6183 counterparty_node_id,
6185 counterparty_shutdown_scriptpubkey,
6187 commitment_secrets: CounterpartyCommitmentSecrets::new(),
6189 channel_update_status: ChannelUpdateStatus::Enabled,
6190 closing_signed_in_flight: false,
6192 announcement_sigs: None,
6194 #[cfg(any(test, fuzzing))]
6195 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
6196 #[cfg(any(test, fuzzing))]
6197 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
6199 workaround_lnd_bug_4006: None,
6200 sent_message_awaiting_response: None,
6202 latest_inbound_scid_alias: None,
6203 outbound_scid_alias,
6205 channel_pending_event_emitted: false,
6206 channel_ready_event_emitted: false,
6208 #[cfg(any(test, fuzzing))]
6209 historical_inbound_htlc_fulfills: HashSet::new(),
6214 blocked_monitor_updates: Vec::new(),
6221 pub fn is_awaiting_accept(&self) -> bool {
6222 self.context.inbound_awaiting_accept
6225 /// Sets this channel to accepting 0conf, must be done before `get_accept_channel`
6226 pub fn set_0conf(&mut self) {
6227 assert!(self.context.inbound_awaiting_accept);
6228 self.context.minimum_depth = Some(0);
6231 /// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannel`] message which
6232 /// should be sent back to the counterparty node.
6234 /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
6235 pub fn accept_inbound_channel(&mut self, user_id: u128) -> msgs::AcceptChannel {
6236 if self.context.is_outbound() {
6237 panic!("Tried to send accept_channel for an outbound channel?");
6239 if self.context.channel_state != (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32) {
6240 panic!("Tried to send accept_channel after channel had moved forward");
6242 if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
6243 panic!("Tried to send an accept_channel for a channel that has already advanced");
6245 if !self.context.inbound_awaiting_accept {
6246 panic!("The inbound channel has already been accepted");
6249 self.context.user_id = user_id;
6250 self.context.inbound_awaiting_accept = false;
6252 self.generate_accept_channel_message()
6255 /// This function is used to explicitly generate a [`msgs::AcceptChannel`] message for an
6256 /// inbound channel. If the intention is to accept an inbound channel, use
6257 /// [`InboundV1Channel::accept_inbound_channel`] instead.
6259 /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
6260 fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
6261 let first_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
6262 let keys = self.context.get_holder_pubkeys();
6264 msgs::AcceptChannel {
6265 temporary_channel_id: self.context.channel_id,
6266 dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
6267 max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
6268 channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
6269 htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
6270 minimum_depth: self.context.minimum_depth.unwrap(),
6271 to_self_delay: self.context.get_holder_selected_contest_delay(),
6272 max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
6273 funding_pubkey: keys.funding_pubkey,
6274 revocation_basepoint: keys.revocation_basepoint,
6275 payment_point: keys.payment_point,
6276 delayed_payment_basepoint: keys.delayed_payment_basepoint,
6277 htlc_basepoint: keys.htlc_basepoint,
6278 first_per_commitment_point,
6279 shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
6280 Some(script) => script.clone().into_inner(),
6281 None => Builder::new().into_script(),
6283 channel_type: Some(self.context.channel_type.clone()),
6285 next_local_nonce: None,
6289 /// Enables the possibility for tests to extract a [`msgs::AcceptChannel`] message for an
6290 /// inbound channel without accepting it.
6292 /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
6294 pub fn get_accept_channel_message(&self) -> msgs::AcceptChannel {
6295 self.generate_accept_channel_message()
6298 fn funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<(Txid, CommitmentTransaction, Signature), ChannelError> where L::Target: Logger {
6299 let funding_script = self.context.get_funding_redeemscript();
6301 let keys = self.context.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
6302 let initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger).tx;
6304 let trusted_tx = initial_commitment_tx.trust();
6305 let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
6306 let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
6307 // They sign the holder commitment transaction...
6308 log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} for channel {}.",
6309 log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.context.counterparty_funding_pubkey().serialize()),
6310 encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]),
6311 encode::serialize_hex(&funding_script), log_bytes!(self.context.channel_id()));
6312 secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &sig, self.context.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
6315 let counterparty_keys = self.context.build_remote_transaction_keys();
6316 let counterparty_initial_commitment_tx = self.context.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
6318 let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
6319 let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
6320 log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
6321 log_bytes!(self.context.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
6323 let counterparty_signature = self.context.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
6324 .map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
6326 // We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
6327 Ok((counterparty_initial_bitcoin_tx.txid, initial_commitment_tx, counterparty_signature))
6330 pub fn funding_created<SP: Deref, L: Deref>(
6331 mut self, msg: &msgs::FundingCreated, best_block: BestBlock, signer_provider: &SP, logger: &L
6332 ) -> Result<(Channel<Signer>, msgs::FundingSigned, ChannelMonitor<Signer>), (Self, ChannelError)>
6334 SP::Target: SignerProvider<Signer = Signer>,
6337 if self.context.is_outbound() {
6338 return Err((self, ChannelError::Close("Received funding_created for an outbound channel?".to_owned())));
6340 if self.context.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
6341 // BOLT 2 says that if we disconnect before we send funding_signed we SHOULD NOT
6342 // remember the channel, so it's safe to just send an error_message here and drop the
6344 return Err((self, ChannelError::Close("Received funding_created after we got the channel!".to_owned())));
6346 if self.context.inbound_awaiting_accept {
6347 return Err((self, ChannelError::Close("FundingCreated message received before the channel was accepted".to_owned())));
6349 if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
6350 self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
6351 self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
6352 panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
6355 let funding_txo = OutPoint { txid: msg.funding_txid, index: msg.funding_output_index };
6356 self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
6357 // This is an externally observable change before we finish all our checks. In particular
6358 // funding_created_signature may fail.
6359 self.context.holder_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
6361 let (counterparty_initial_commitment_txid, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
6363 Err(ChannelError::Close(e)) => {
6364 self.context.channel_transaction_parameters.funding_outpoint = None;
6365 return Err((self, ChannelError::Close(e)));
6368 // The only error we know how to handle is ChannelError::Close, so we fall over here
6369 // to make sure we don't continue with an inconsistent state.
6370 panic!("unexpected error type from funding_created_signature {:?}", e);
6374 let holder_commitment_tx = HolderCommitmentTransaction::new(
6375 initial_commitment_tx,
6378 &self.context.get_holder_pubkeys().funding_pubkey,
6379 self.context.counterparty_funding_pubkey()
6382 if let Err(_) = self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new()) {
6383 return Err((self, ChannelError::Close("Failed to validate our commitment".to_owned())));
6386 // Now that we're past error-generating stuff, update our local state:
6388 let funding_redeemscript = self.context.get_funding_redeemscript();
6389 let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
6390 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());
6391 let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
6392 let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
6393 monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
6394 let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
6395 shutdown_script, self.context.get_holder_selected_contest_delay(),
6396 &self.context.destination_script, (funding_txo, funding_txo_script.clone()),
6397 &self.context.channel_transaction_parameters,
6398 funding_redeemscript.clone(), self.context.channel_value_satoshis,
6400 holder_commitment_tx, best_block, self.context.counterparty_node_id);
6402 channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_commitment_txid, Vec::new(), self.context.cur_counterparty_commitment_transaction_number, self.context.counterparty_cur_commitment_point.unwrap(), logger);
6404 self.context.channel_state = ChannelState::FundingSent as u32;
6405 self.context.channel_id = funding_txo.to_channel_id();
6406 self.context.cur_counterparty_commitment_transaction_number -= 1;
6407 self.context.cur_holder_commitment_transaction_number -= 1;
6409 log_info!(logger, "Generated funding_signed for peer for channel {}", log_bytes!(self.context.channel_id()));
6411 // Promote the channel to a full-fledged one now that we have updated the state and have a
6412 // `ChannelMonitor`.
6413 let mut channel = Channel {
6414 context: self.context,
6416 let channel_id = channel.context.channel_id.clone();
6417 let need_channel_ready = channel.check_get_channel_ready(0).is_some();
6418 channel.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
6420 Ok((channel, msgs::FundingSigned {
6424 partial_signature_with_nonce: None,
6425 }, channel_monitor))
6429 const SERIALIZATION_VERSION: u8 = 3;
6430 const MIN_SERIALIZATION_VERSION: u8 = 2;
6432 impl_writeable_tlv_based_enum!(InboundHTLCRemovalReason,;
6438 impl Writeable for ChannelUpdateStatus {
6439 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6440 // We only care about writing out the current state as it was announced, ie only either
6441 // Enabled or Disabled. In the case of DisabledStaged, we most recently announced the
6442 // channel as enabled, so we write 0. For EnabledStaged, we similarly write a 1.
6444 ChannelUpdateStatus::Enabled => 0u8.write(writer)?,
6445 ChannelUpdateStatus::DisabledStaged(_) => 0u8.write(writer)?,
6446 ChannelUpdateStatus::EnabledStaged(_) => 1u8.write(writer)?,
6447 ChannelUpdateStatus::Disabled => 1u8.write(writer)?,
6453 impl Readable for ChannelUpdateStatus {
6454 fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
6455 Ok(match <u8 as Readable>::read(reader)? {
6456 0 => ChannelUpdateStatus::Enabled,
6457 1 => ChannelUpdateStatus::Disabled,
6458 _ => return Err(DecodeError::InvalidValue),
6463 impl Writeable for AnnouncementSigsState {
6464 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6465 // We only care about writing out the current state as if we had just disconnected, at
6466 // which point we always set anything but AnnouncementSigsReceived to NotSent.
6468 AnnouncementSigsState::NotSent => 0u8.write(writer),
6469 AnnouncementSigsState::MessageSent => 0u8.write(writer),
6470 AnnouncementSigsState::Committed => 0u8.write(writer),
6471 AnnouncementSigsState::PeerReceived => 1u8.write(writer),
6476 impl Readable for AnnouncementSigsState {
6477 fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
6478 Ok(match <u8 as Readable>::read(reader)? {
6479 0 => AnnouncementSigsState::NotSent,
6480 1 => AnnouncementSigsState::PeerReceived,
6481 _ => return Err(DecodeError::InvalidValue),
6486 impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
6487 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6488 // Note that we write out as if remove_uncommitted_htlcs_and_mark_paused had just been
6491 write_ver_prefix!(writer, MIN_SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
6493 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6494 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We write
6495 // the low bytes now and the optional high bytes later.
6496 let user_id_low = self.context.user_id as u64;
6497 user_id_low.write(writer)?;
6499 // Version 1 deserializers expected to read parts of the config object here. Version 2
6500 // deserializers (0.0.99) now read config through TLVs, and as we now require them for
6501 // `minimum_depth` we simply write dummy values here.
6502 writer.write_all(&[0; 8])?;
6504 self.context.channel_id.write(writer)?;
6505 (self.context.channel_state | ChannelState::PeerDisconnected as u32).write(writer)?;
6506 self.context.channel_value_satoshis.write(writer)?;
6508 self.context.latest_monitor_update_id.write(writer)?;
6510 let mut key_data = VecWriter(Vec::new());
6511 self.context.holder_signer.write(&mut key_data)?;
6512 assert!(key_data.0.len() < core::usize::MAX);
6513 assert!(key_data.0.len() < core::u32::MAX as usize);
6514 (key_data.0.len() as u32).write(writer)?;
6515 writer.write_all(&key_data.0[..])?;
6517 // Write out the old serialization for shutdown_pubkey for backwards compatibility, if
6518 // deserialized from that format.
6519 match self.context.shutdown_scriptpubkey.as_ref().and_then(|script| script.as_legacy_pubkey()) {
6520 Some(shutdown_pubkey) => shutdown_pubkey.write(writer)?,
6521 None => [0u8; PUBLIC_KEY_SIZE].write(writer)?,
6523 self.context.destination_script.write(writer)?;
6525 self.context.cur_holder_commitment_transaction_number.write(writer)?;
6526 self.context.cur_counterparty_commitment_transaction_number.write(writer)?;
6527 self.context.value_to_self_msat.write(writer)?;
6529 let mut dropped_inbound_htlcs = 0;
6530 for htlc in self.context.pending_inbound_htlcs.iter() {
6531 if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
6532 dropped_inbound_htlcs += 1;
6535 (self.context.pending_inbound_htlcs.len() as u64 - dropped_inbound_htlcs).write(writer)?;
6536 for htlc in self.context.pending_inbound_htlcs.iter() {
6537 if let &InboundHTLCState::RemoteAnnounced(_) = &htlc.state {
6540 htlc.htlc_id.write(writer)?;
6541 htlc.amount_msat.write(writer)?;
6542 htlc.cltv_expiry.write(writer)?;
6543 htlc.payment_hash.write(writer)?;
6545 &InboundHTLCState::RemoteAnnounced(_) => unreachable!(),
6546 &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref htlc_state) => {
6548 htlc_state.write(writer)?;
6550 &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(ref htlc_state) => {
6552 htlc_state.write(writer)?;
6554 &InboundHTLCState::Committed => {
6557 &InboundHTLCState::LocalRemoved(ref removal_reason) => {
6559 removal_reason.write(writer)?;
6564 let mut preimages: Vec<&Option<PaymentPreimage>> = vec![];
6565 let mut pending_outbound_skimmed_fees: Vec<Option<u64>> = Vec::new();
6567 (self.context.pending_outbound_htlcs.len() as u64).write(writer)?;
6568 for (idx, htlc) in self.context.pending_outbound_htlcs.iter().enumerate() {
6569 htlc.htlc_id.write(writer)?;
6570 htlc.amount_msat.write(writer)?;
6571 htlc.cltv_expiry.write(writer)?;
6572 htlc.payment_hash.write(writer)?;
6573 htlc.source.write(writer)?;
6575 &OutboundHTLCState::LocalAnnounced(ref onion_packet) => {
6577 onion_packet.write(writer)?;
6579 &OutboundHTLCState::Committed => {
6582 &OutboundHTLCState::RemoteRemoved(_) => {
6583 // Treat this as a Committed because we haven't received the CS - they'll
6584 // resend the claim/fail on reconnect as we all (hopefully) the missing CS.
6587 &OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref outcome) => {
6589 if let OutboundHTLCOutcome::Success(preimage) = outcome {
6590 preimages.push(preimage);
6592 let reason: Option<&HTLCFailReason> = outcome.into();
6593 reason.write(writer)?;
6595 &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) => {
6597 if let OutboundHTLCOutcome::Success(preimage) = outcome {
6598 preimages.push(preimage);
6600 let reason: Option<&HTLCFailReason> = outcome.into();
6601 reason.write(writer)?;
6604 if let Some(skimmed_fee) = htlc.skimmed_fee_msat {
6605 if pending_outbound_skimmed_fees.is_empty() {
6606 for _ in 0..idx { pending_outbound_skimmed_fees.push(None); }
6608 pending_outbound_skimmed_fees.push(Some(skimmed_fee));
6609 } else if !pending_outbound_skimmed_fees.is_empty() {
6610 pending_outbound_skimmed_fees.push(None);
6614 let mut holding_cell_skimmed_fees: Vec<Option<u64>> = Vec::new();
6615 (self.context.holding_cell_htlc_updates.len() as u64).write(writer)?;
6616 for (idx, update) in self.context.holding_cell_htlc_updates.iter().enumerate() {
6618 &HTLCUpdateAwaitingACK::AddHTLC {
6619 ref amount_msat, ref cltv_expiry, ref payment_hash, ref source, ref onion_routing_packet,
6623 amount_msat.write(writer)?;
6624 cltv_expiry.write(writer)?;
6625 payment_hash.write(writer)?;
6626 source.write(writer)?;
6627 onion_routing_packet.write(writer)?;
6629 if let Some(skimmed_fee) = skimmed_fee_msat {
6630 if holding_cell_skimmed_fees.is_empty() {
6631 for _ in 0..idx { holding_cell_skimmed_fees.push(None); }
6633 holding_cell_skimmed_fees.push(Some(skimmed_fee));
6634 } else if !holding_cell_skimmed_fees.is_empty() { holding_cell_skimmed_fees.push(None); }
6636 &HTLCUpdateAwaitingACK::ClaimHTLC { ref payment_preimage, ref htlc_id } => {
6638 payment_preimage.write(writer)?;
6639 htlc_id.write(writer)?;
6641 &HTLCUpdateAwaitingACK::FailHTLC { ref htlc_id, ref err_packet } => {
6643 htlc_id.write(writer)?;
6644 err_packet.write(writer)?;
6649 match self.context.resend_order {
6650 RAACommitmentOrder::CommitmentFirst => 0u8.write(writer)?,
6651 RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
6654 self.context.monitor_pending_channel_ready.write(writer)?;
6655 self.context.monitor_pending_revoke_and_ack.write(writer)?;
6656 self.context.monitor_pending_commitment_signed.write(writer)?;
6658 (self.context.monitor_pending_forwards.len() as u64).write(writer)?;
6659 for &(ref pending_forward, ref htlc_id) in self.context.monitor_pending_forwards.iter() {
6660 pending_forward.write(writer)?;
6661 htlc_id.write(writer)?;
6664 (self.context.monitor_pending_failures.len() as u64).write(writer)?;
6665 for &(ref htlc_source, ref payment_hash, ref fail_reason) in self.context.monitor_pending_failures.iter() {
6666 htlc_source.write(writer)?;
6667 payment_hash.write(writer)?;
6668 fail_reason.write(writer)?;
6671 if self.context.is_outbound() {
6672 self.context.pending_update_fee.map(|(a, _)| a).write(writer)?;
6673 } else if let Some((feerate, FeeUpdateState::AwaitingRemoteRevokeToAnnounce)) = self.context.pending_update_fee {
6674 Some(feerate).write(writer)?;
6676 // As for inbound HTLCs, if the update was only announced and never committed in a
6677 // commitment_signed, drop it.
6678 None::<u32>.write(writer)?;
6680 self.context.holding_cell_update_fee.write(writer)?;
6682 self.context.next_holder_htlc_id.write(writer)?;
6683 (self.context.next_counterparty_htlc_id - dropped_inbound_htlcs).write(writer)?;
6684 self.context.update_time_counter.write(writer)?;
6685 self.context.feerate_per_kw.write(writer)?;
6687 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
6688 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
6689 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
6690 // consider the stale state on reload.
6693 self.context.funding_tx_confirmed_in.write(writer)?;
6694 self.context.funding_tx_confirmation_height.write(writer)?;
6695 self.context.short_channel_id.write(writer)?;
6697 self.context.counterparty_dust_limit_satoshis.write(writer)?;
6698 self.context.holder_dust_limit_satoshis.write(writer)?;
6699 self.context.counterparty_max_htlc_value_in_flight_msat.write(writer)?;
6701 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
6702 self.context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;
6704 self.context.counterparty_htlc_minimum_msat.write(writer)?;
6705 self.context.holder_htlc_minimum_msat.write(writer)?;
6706 self.context.counterparty_max_accepted_htlcs.write(writer)?;
6708 // Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
6709 self.context.minimum_depth.unwrap_or(0).write(writer)?;
6711 match &self.context.counterparty_forwarding_info {
6714 info.fee_base_msat.write(writer)?;
6715 info.fee_proportional_millionths.write(writer)?;
6716 info.cltv_expiry_delta.write(writer)?;
6718 None => 0u8.write(writer)?
6721 self.context.channel_transaction_parameters.write(writer)?;
6722 self.context.funding_transaction.write(writer)?;
6724 self.context.counterparty_cur_commitment_point.write(writer)?;
6725 self.context.counterparty_prev_commitment_point.write(writer)?;
6726 self.context.counterparty_node_id.write(writer)?;
6728 self.context.counterparty_shutdown_scriptpubkey.write(writer)?;
6730 self.context.commitment_secrets.write(writer)?;
6732 self.context.channel_update_status.write(writer)?;
6734 #[cfg(any(test, fuzzing))]
6735 (self.context.historical_inbound_htlc_fulfills.len() as u64).write(writer)?;
6736 #[cfg(any(test, fuzzing))]
6737 for htlc in self.context.historical_inbound_htlc_fulfills.iter() {
6738 htlc.write(writer)?;
6741 // If the channel type is something other than only-static-remote-key, then we need to have
6742 // older clients fail to deserialize this channel at all. If the type is
6743 // only-static-remote-key, we simply consider it "default" and don't write the channel type
6745 let chan_type = if self.context.channel_type != ChannelTypeFeatures::only_static_remote_key() {
6746 Some(&self.context.channel_type) } else { None };
6748 // The same logic applies for `holder_selected_channel_reserve_satoshis` values other than
6749 // the default, and when `holder_max_htlc_value_in_flight_msat` is configured to be set to
6750 // a different percentage of the channel value then 10%, which older versions of LDK used
6751 // to set it to before the percentage was made configurable.
6752 let serialized_holder_selected_reserve =
6753 if self.context.holder_selected_channel_reserve_satoshis != get_legacy_default_holder_selected_channel_reserve_satoshis(self.context.channel_value_satoshis)
6754 { Some(self.context.holder_selected_channel_reserve_satoshis) } else { None };
6756 let mut old_max_in_flight_percent_config = UserConfig::default().channel_handshake_config;
6757 old_max_in_flight_percent_config.max_inbound_htlc_value_in_flight_percent_of_channel = MAX_IN_FLIGHT_PERCENT_LEGACY;
6758 let serialized_holder_htlc_max_in_flight =
6759 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)
6760 { Some(self.context.holder_max_htlc_value_in_flight_msat) } else { None };
6762 let channel_pending_event_emitted = Some(self.context.channel_pending_event_emitted);
6763 let channel_ready_event_emitted = Some(self.context.channel_ready_event_emitted);
6765 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6766 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. Therefore,
6767 // we write the high bytes as an option here.
6768 let user_id_high_opt = Some((self.context.user_id >> 64) as u64);
6770 let holder_max_accepted_htlcs = if self.context.holder_max_accepted_htlcs == DEFAULT_MAX_HTLCS { None } else { Some(self.context.holder_max_accepted_htlcs) };
6772 write_tlv_fields!(writer, {
6773 (0, self.context.announcement_sigs, option),
6774 // minimum_depth and counterparty_selected_channel_reserve_satoshis used to have a
6775 // default value instead of being Option<>al. Thus, to maintain compatibility we write
6776 // them twice, once with their original default values above, and once as an option
6777 // here. On the read side, old versions will simply ignore the odd-type entries here,
6778 // and new versions map the default values to None and allow the TLV entries here to
6780 (1, self.context.minimum_depth, option),
6781 (2, chan_type, option),
6782 (3, self.context.counterparty_selected_channel_reserve_satoshis, option),
6783 (4, serialized_holder_selected_reserve, option),
6784 (5, self.context.config, required),
6785 (6, serialized_holder_htlc_max_in_flight, option),
6786 (7, self.context.shutdown_scriptpubkey, option),
6787 (9, self.context.target_closing_feerate_sats_per_kw, option),
6788 (11, self.context.monitor_pending_finalized_fulfills, vec_type),
6789 (13, self.context.channel_creation_height, required),
6790 (15, preimages, vec_type),
6791 (17, self.context.announcement_sigs_state, required),
6792 (19, self.context.latest_inbound_scid_alias, option),
6793 (21, self.context.outbound_scid_alias, required),
6794 (23, channel_ready_event_emitted, option),
6795 (25, user_id_high_opt, option),
6796 (27, self.context.channel_keys_id, required),
6797 (28, holder_max_accepted_htlcs, option),
6798 (29, self.context.temporary_channel_id, option),
6799 (31, channel_pending_event_emitted, option),
6800 (33, self.context.blocked_monitor_updates, vec_type),
6801 (35, pending_outbound_skimmed_fees, optional_vec),
6802 (37, holding_cell_skimmed_fees, optional_vec),
6809 const MAX_ALLOC_SIZE: usize = 64*1024;
6810 impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)> for Channel<<SP::Target as SignerProvider>::Signer>
6812 ES::Target: EntropySource,
6813 SP::Target: SignerProvider
6815 fn read<R : io::Read>(reader: &mut R, args: (&'a ES, &'b SP, u32, &'c ChannelTypeFeatures)) -> Result<Self, DecodeError> {
6816 let (entropy_source, signer_provider, serialized_height, our_supported_features) = args;
6817 let ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
6819 // `user_id` used to be a single u64 value. In order to remain backwards compatible with
6820 // versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We read
6821 // the low bytes now and the high bytes later.
6822 let user_id_low: u64 = Readable::read(reader)?;
6824 let mut config = Some(LegacyChannelConfig::default());
6826 // Read the old serialization of the ChannelConfig from version 0.0.98.
6827 config.as_mut().unwrap().options.forwarding_fee_proportional_millionths = Readable::read(reader)?;
6828 config.as_mut().unwrap().options.cltv_expiry_delta = Readable::read(reader)?;
6829 config.as_mut().unwrap().announced_channel = Readable::read(reader)?;
6830 config.as_mut().unwrap().commit_upfront_shutdown_pubkey = Readable::read(reader)?;
6832 // Read the 8 bytes of backwards-compatibility ChannelConfig data.
6833 let mut _val: u64 = Readable::read(reader)?;
6836 let channel_id = Readable::read(reader)?;
6837 let channel_state = Readable::read(reader)?;
6838 let channel_value_satoshis = Readable::read(reader)?;
6840 let latest_monitor_update_id = Readable::read(reader)?;
6842 let mut keys_data = None;
6844 // Read the serialize signer bytes. We'll choose to deserialize them or not based on whether
6845 // the `channel_keys_id` TLV is present below.
6846 let keys_len: u32 = Readable::read(reader)?;
6847 keys_data = Some(Vec::with_capacity(cmp::min(keys_len as usize, MAX_ALLOC_SIZE)));
6848 while keys_data.as_ref().unwrap().len() != keys_len as usize {
6849 // Read 1KB at a time to avoid accidentally allocating 4GB on corrupted channel keys
6850 let mut data = [0; 1024];
6851 let read_slice = &mut data[0..cmp::min(1024, keys_len as usize - keys_data.as_ref().unwrap().len())];
6852 reader.read_exact(read_slice)?;
6853 keys_data.as_mut().unwrap().extend_from_slice(read_slice);
6857 // Read the old serialization for shutdown_pubkey, preferring the TLV field later if set.
6858 let mut shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
6859 Ok(pubkey) => Some(ShutdownScript::new_p2wpkh_from_pubkey(pubkey)),
6862 let destination_script = Readable::read(reader)?;
6864 let cur_holder_commitment_transaction_number = Readable::read(reader)?;
6865 let cur_counterparty_commitment_transaction_number = Readable::read(reader)?;
6866 let value_to_self_msat = Readable::read(reader)?;
6868 let pending_inbound_htlc_count: u64 = Readable::read(reader)?;
6870 let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(pending_inbound_htlc_count as usize, DEFAULT_MAX_HTLCS as usize));
6871 for _ in 0..pending_inbound_htlc_count {
6872 pending_inbound_htlcs.push(InboundHTLCOutput {
6873 htlc_id: Readable::read(reader)?,
6874 amount_msat: Readable::read(reader)?,
6875 cltv_expiry: Readable::read(reader)?,
6876 payment_hash: Readable::read(reader)?,
6877 state: match <u8 as Readable>::read(reader)? {
6878 1 => InboundHTLCState::AwaitingRemoteRevokeToAnnounce(Readable::read(reader)?),
6879 2 => InboundHTLCState::AwaitingAnnouncedRemoteRevoke(Readable::read(reader)?),
6880 3 => InboundHTLCState::Committed,
6881 4 => InboundHTLCState::LocalRemoved(Readable::read(reader)?),
6882 _ => return Err(DecodeError::InvalidValue),
6887 let pending_outbound_htlc_count: u64 = Readable::read(reader)?;
6888 let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(pending_outbound_htlc_count as usize, DEFAULT_MAX_HTLCS as usize));
6889 for _ in 0..pending_outbound_htlc_count {
6890 pending_outbound_htlcs.push(OutboundHTLCOutput {
6891 htlc_id: Readable::read(reader)?,
6892 amount_msat: Readable::read(reader)?,
6893 cltv_expiry: Readable::read(reader)?,
6894 payment_hash: Readable::read(reader)?,
6895 source: Readable::read(reader)?,
6896 state: match <u8 as Readable>::read(reader)? {
6897 0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
6898 1 => OutboundHTLCState::Committed,
6900 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6901 OutboundHTLCState::RemoteRemoved(option.into())
6904 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6905 OutboundHTLCState::AwaitingRemoteRevokeToRemove(option.into())
6908 let option: Option<HTLCFailReason> = Readable::read(reader)?;
6909 OutboundHTLCState::AwaitingRemovedRemoteRevoke(option.into())
6911 _ => return Err(DecodeError::InvalidValue),
6913 skimmed_fee_msat: None,
6917 let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
6918 let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, DEFAULT_MAX_HTLCS as usize*2));
6919 for _ in 0..holding_cell_htlc_update_count {
6920 holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
6921 0 => HTLCUpdateAwaitingACK::AddHTLC {
6922 amount_msat: Readable::read(reader)?,
6923 cltv_expiry: Readable::read(reader)?,
6924 payment_hash: Readable::read(reader)?,
6925 source: Readable::read(reader)?,
6926 onion_routing_packet: Readable::read(reader)?,
6927 skimmed_fee_msat: None,
6929 1 => HTLCUpdateAwaitingACK::ClaimHTLC {
6930 payment_preimage: Readable::read(reader)?,
6931 htlc_id: Readable::read(reader)?,
6933 2 => HTLCUpdateAwaitingACK::FailHTLC {
6934 htlc_id: Readable::read(reader)?,
6935 err_packet: Readable::read(reader)?,
6937 _ => return Err(DecodeError::InvalidValue),
6941 let resend_order = match <u8 as Readable>::read(reader)? {
6942 0 => RAACommitmentOrder::CommitmentFirst,
6943 1 => RAACommitmentOrder::RevokeAndACKFirst,
6944 _ => return Err(DecodeError::InvalidValue),
6947 let monitor_pending_channel_ready = Readable::read(reader)?;
6948 let monitor_pending_revoke_and_ack = Readable::read(reader)?;
6949 let monitor_pending_commitment_signed = Readable::read(reader)?;
6951 let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
6952 let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(monitor_pending_forwards_count as usize, DEFAULT_MAX_HTLCS as usize));
6953 for _ in 0..monitor_pending_forwards_count {
6954 monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
6957 let monitor_pending_failures_count: u64 = Readable::read(reader)?;
6958 let mut monitor_pending_failures = Vec::with_capacity(cmp::min(monitor_pending_failures_count as usize, DEFAULT_MAX_HTLCS as usize));
6959 for _ in 0..monitor_pending_failures_count {
6960 monitor_pending_failures.push((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?));
6963 let pending_update_fee_value: Option<u32> = Readable::read(reader)?;
6965 let holding_cell_update_fee = Readable::read(reader)?;
6967 let next_holder_htlc_id = Readable::read(reader)?;
6968 let next_counterparty_htlc_id = Readable::read(reader)?;
6969 let update_time_counter = Readable::read(reader)?;
6970 let feerate_per_kw = Readable::read(reader)?;
6972 // Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
6973 // however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
6974 // `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
6975 // consider the stale state on reload.
6976 match <u8 as Readable>::read(reader)? {
6979 let _: u32 = Readable::read(reader)?;
6980 let _: u64 = Readable::read(reader)?;
6981 let _: Signature = Readable::read(reader)?;
6983 _ => return Err(DecodeError::InvalidValue),
6986 let funding_tx_confirmed_in = Readable::read(reader)?;
6987 let funding_tx_confirmation_height = Readable::read(reader)?;
6988 let short_channel_id = Readable::read(reader)?;
6990 let counterparty_dust_limit_satoshis = Readable::read(reader)?;
6991 let holder_dust_limit_satoshis = Readable::read(reader)?;
6992 let counterparty_max_htlc_value_in_flight_msat = Readable::read(reader)?;
6993 let mut counterparty_selected_channel_reserve_satoshis = None;
6995 // Read the old serialization from version 0.0.98.
6996 counterparty_selected_channel_reserve_satoshis = Some(Readable::read(reader)?);
6998 // Read the 8 bytes of backwards-compatibility data.
6999 let _dummy: u64 = Readable::read(reader)?;
7001 let counterparty_htlc_minimum_msat = Readable::read(reader)?;
7002 let holder_htlc_minimum_msat = Readable::read(reader)?;
7003 let counterparty_max_accepted_htlcs = Readable::read(reader)?;
7005 let mut minimum_depth = None;
7007 // Read the old serialization from version 0.0.98.
7008 minimum_depth = Some(Readable::read(reader)?);
7010 // Read the 4 bytes of backwards-compatibility data.
7011 let _dummy: u32 = Readable::read(reader)?;
7014 let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
7016 1 => Some(CounterpartyForwardingInfo {
7017 fee_base_msat: Readable::read(reader)?,
7018 fee_proportional_millionths: Readable::read(reader)?,
7019 cltv_expiry_delta: Readable::read(reader)?,
7021 _ => return Err(DecodeError::InvalidValue),
7024 let mut channel_parameters: ChannelTransactionParameters = Readable::read(reader)?;
7025 let funding_transaction = Readable::read(reader)?;
7027 let counterparty_cur_commitment_point = Readable::read(reader)?;
7029 let counterparty_prev_commitment_point = Readable::read(reader)?;
7030 let counterparty_node_id = Readable::read(reader)?;
7032 let counterparty_shutdown_scriptpubkey = Readable::read(reader)?;
7033 let commitment_secrets = Readable::read(reader)?;
7035 let channel_update_status = Readable::read(reader)?;
7037 #[cfg(any(test, fuzzing))]
7038 let mut historical_inbound_htlc_fulfills = HashSet::new();
7039 #[cfg(any(test, fuzzing))]
7041 let htlc_fulfills_len: u64 = Readable::read(reader)?;
7042 for _ in 0..htlc_fulfills_len {
7043 assert!(historical_inbound_htlc_fulfills.insert(Readable::read(reader)?));
7047 let pending_update_fee = if let Some(feerate) = pending_update_fee_value {
7048 Some((feerate, if channel_parameters.is_outbound_from_holder {
7049 FeeUpdateState::Outbound
7051 FeeUpdateState::AwaitingRemoteRevokeToAnnounce
7057 let mut announcement_sigs = None;
7058 let mut target_closing_feerate_sats_per_kw = None;
7059 let mut monitor_pending_finalized_fulfills = Some(Vec::new());
7060 let mut holder_selected_channel_reserve_satoshis = Some(get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis));
7061 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));
7062 // Prior to supporting channel type negotiation, all of our channels were static_remotekey
7063 // only, so we default to that if none was written.
7064 let mut channel_type = Some(ChannelTypeFeatures::only_static_remote_key());
7065 let mut channel_creation_height = Some(serialized_height);
7066 let mut preimages_opt: Option<Vec<Option<PaymentPreimage>>> = None;
7068 // If we read an old Channel, for simplicity we just treat it as "we never sent an
7069 // AnnouncementSignatures" which implies we'll re-send it on reconnect, but that's fine.
7070 let mut announcement_sigs_state = Some(AnnouncementSigsState::NotSent);
7071 let mut latest_inbound_scid_alias = None;
7072 let mut outbound_scid_alias = None;
7073 let mut channel_pending_event_emitted = None;
7074 let mut channel_ready_event_emitted = None;
7076 let mut user_id_high_opt: Option<u64> = None;
7077 let mut channel_keys_id: Option<[u8; 32]> = None;
7078 let mut temporary_channel_id: Option<[u8; 32]> = None;
7079 let mut holder_max_accepted_htlcs: Option<u16> = None;
7081 let mut blocked_monitor_updates = Some(Vec::new());
7083 let mut pending_outbound_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;
7084 let mut holding_cell_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;
7086 read_tlv_fields!(reader, {
7087 (0, announcement_sigs, option),
7088 (1, minimum_depth, option),
7089 (2, channel_type, option),
7090 (3, counterparty_selected_channel_reserve_satoshis, option),
7091 (4, holder_selected_channel_reserve_satoshis, option),
7092 (5, config, option), // Note that if none is provided we will *not* overwrite the existing one.
7093 (6, holder_max_htlc_value_in_flight_msat, option),
7094 (7, shutdown_scriptpubkey, option),
7095 (9, target_closing_feerate_sats_per_kw, option),
7096 (11, monitor_pending_finalized_fulfills, vec_type),
7097 (13, channel_creation_height, option),
7098 (15, preimages_opt, vec_type),
7099 (17, announcement_sigs_state, option),
7100 (19, latest_inbound_scid_alias, option),
7101 (21, outbound_scid_alias, option),
7102 (23, channel_ready_event_emitted, option),
7103 (25, user_id_high_opt, option),
7104 (27, channel_keys_id, option),
7105 (28, holder_max_accepted_htlcs, option),
7106 (29, temporary_channel_id, option),
7107 (31, channel_pending_event_emitted, option),
7108 (33, blocked_monitor_updates, vec_type),
7109 (35, pending_outbound_skimmed_fees_opt, optional_vec),
7110 (37, holding_cell_skimmed_fees_opt, optional_vec),
7113 let (channel_keys_id, holder_signer) = if let Some(channel_keys_id) = channel_keys_id {
7114 let mut holder_signer = signer_provider.derive_channel_signer(channel_value_satoshis, channel_keys_id);
7115 // If we've gotten to the funding stage of the channel, populate the signer with its
7116 // required channel parameters.
7117 let non_shutdown_state = channel_state & (!MULTI_STATE_FLAGS);
7118 if non_shutdown_state >= (ChannelState::FundingCreated as u32) {
7119 holder_signer.provide_channel_parameters(&channel_parameters);
7121 (channel_keys_id, holder_signer)
7123 // `keys_data` can be `None` if we had corrupted data.
7124 let keys_data = keys_data.ok_or(DecodeError::InvalidValue)?;
7125 let holder_signer = signer_provider.read_chan_signer(&keys_data)?;
7126 (holder_signer.channel_keys_id(), holder_signer)
7129 if let Some(preimages) = preimages_opt {
7130 let mut iter = preimages.into_iter();
7131 for htlc in pending_outbound_htlcs.iter_mut() {
7133 OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(None)) => {
7134 htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
7136 OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(None)) => {
7137 htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(iter.next().ok_or(DecodeError::InvalidValue)?));
7142 // We expect all preimages to be consumed above
7143 if iter.next().is_some() {
7144 return Err(DecodeError::InvalidValue);
7148 let chan_features = channel_type.as_ref().unwrap();
7149 if !chan_features.is_subset(our_supported_features) {
7150 // If the channel was written by a new version and negotiated with features we don't
7151 // understand yet, refuse to read it.
7152 return Err(DecodeError::UnknownRequiredFeature);
7155 // ChannelTransactionParameters may have had an empty features set upon deserialization.
7156 // To account for that, we're proactively setting/overriding the field here.
7157 channel_parameters.channel_type_features = chan_features.clone();
7159 let mut secp_ctx = Secp256k1::new();
7160 secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
7162 // `user_id` used to be a single u64 value. In order to remain backwards
7163 // compatible with versions prior to 0.0.113, the u128 is serialized as two
7164 // separate u64 values.
7165 let user_id = user_id_low as u128 + ((user_id_high_opt.unwrap_or(0) as u128) << 64);
7167 let holder_max_accepted_htlcs = holder_max_accepted_htlcs.unwrap_or(DEFAULT_MAX_HTLCS);
7169 if let Some(skimmed_fees) = pending_outbound_skimmed_fees_opt {
7170 let mut iter = skimmed_fees.into_iter();
7171 for htlc in pending_outbound_htlcs.iter_mut() {
7172 htlc.skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
7174 // We expect all skimmed fees to be consumed above
7175 if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
7177 if let Some(skimmed_fees) = holding_cell_skimmed_fees_opt {
7178 let mut iter = skimmed_fees.into_iter();
7179 for htlc in holding_cell_htlc_updates.iter_mut() {
7180 if let HTLCUpdateAwaitingACK::AddHTLC { ref mut skimmed_fee_msat, .. } = htlc {
7181 *skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
7184 // We expect all skimmed fees to be consumed above
7185 if iter.next().is_some() { return Err(DecodeError::InvalidValue) }
7189 context: ChannelContext {
7192 config: config.unwrap(),
7196 // Note that we don't care about serializing handshake limits as we only ever serialize
7197 // channel data after the handshake has completed.
7198 inbound_handshake_limits_override: None,
7201 temporary_channel_id,
7203 announcement_sigs_state: announcement_sigs_state.unwrap(),
7205 channel_value_satoshis,
7207 latest_monitor_update_id,
7210 shutdown_scriptpubkey,
7213 cur_holder_commitment_transaction_number,
7214 cur_counterparty_commitment_transaction_number,
7217 holder_max_accepted_htlcs,
7218 pending_inbound_htlcs,
7219 pending_outbound_htlcs,
7220 holding_cell_htlc_updates,
7224 monitor_pending_channel_ready,
7225 monitor_pending_revoke_and_ack,
7226 monitor_pending_commitment_signed,
7227 monitor_pending_forwards,
7228 monitor_pending_failures,
7229 monitor_pending_finalized_fulfills: monitor_pending_finalized_fulfills.unwrap(),
7232 holding_cell_update_fee,
7233 next_holder_htlc_id,
7234 next_counterparty_htlc_id,
7235 update_time_counter,
7238 #[cfg(debug_assertions)]
7239 holder_max_commitment_tx_output: Mutex::new((0, 0)),
7240 #[cfg(debug_assertions)]
7241 counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
7243 last_sent_closing_fee: None,
7244 pending_counterparty_closing_signed: None,
7245 closing_fee_limits: None,
7246 target_closing_feerate_sats_per_kw,
7248 inbound_awaiting_accept: false,
7250 funding_tx_confirmed_in,
7251 funding_tx_confirmation_height,
7253 channel_creation_height: channel_creation_height.unwrap(),
7255 counterparty_dust_limit_satoshis,
7256 holder_dust_limit_satoshis,
7257 counterparty_max_htlc_value_in_flight_msat,
7258 holder_max_htlc_value_in_flight_msat: holder_max_htlc_value_in_flight_msat.unwrap(),
7259 counterparty_selected_channel_reserve_satoshis,
7260 holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.unwrap(),
7261 counterparty_htlc_minimum_msat,
7262 holder_htlc_minimum_msat,
7263 counterparty_max_accepted_htlcs,
7266 counterparty_forwarding_info,
7268 channel_transaction_parameters: channel_parameters,
7269 funding_transaction,
7271 counterparty_cur_commitment_point,
7272 counterparty_prev_commitment_point,
7273 counterparty_node_id,
7275 counterparty_shutdown_scriptpubkey,
7279 channel_update_status,
7280 closing_signed_in_flight: false,
7284 #[cfg(any(test, fuzzing))]
7285 next_local_commitment_tx_fee_info_cached: Mutex::new(None),
7286 #[cfg(any(test, fuzzing))]
7287 next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
7289 workaround_lnd_bug_4006: None,
7290 sent_message_awaiting_response: None,
7292 latest_inbound_scid_alias,
7293 // Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
7294 outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
7296 channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
7297 channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
7299 #[cfg(any(test, fuzzing))]
7300 historical_inbound_htlc_fulfills,
7302 channel_type: channel_type.unwrap(),
7305 blocked_monitor_updates: blocked_monitor_updates.unwrap(),
7314 use bitcoin::blockdata::script::{Script, Builder};
7315 use bitcoin::blockdata::transaction::{Transaction, TxOut};
7316 use bitcoin::blockdata::constants::genesis_block;
7317 use bitcoin::blockdata::opcodes;
7318 use bitcoin::network::constants::Network;
7320 use crate::ln::PaymentHash;
7321 use crate::ln::channelmanager::{self, HTLCSource, PaymentId};
7322 use crate::ln::channel::InitFeatures;
7323 use crate::ln::channel::{Channel, InboundHTLCOutput, OutboundV1Channel, InboundV1Channel, OutboundHTLCOutput, InboundHTLCState, OutboundHTLCState, HTLCCandidate, HTLCInitiator, commit_tx_fee_msat};
7324 use crate::ln::channel::{MAX_FUNDING_SATOSHIS_NO_WUMBO, TOTAL_BITCOIN_SUPPLY_SATOSHIS, MIN_THEIR_CHAN_RESERVE_SATOSHIS};
7325 use crate::ln::features::ChannelTypeFeatures;
7326 use crate::ln::msgs::{ChannelUpdate, DecodeError, UnsignedChannelUpdate, MAX_VALUE_MSAT};
7327 use crate::ln::script::ShutdownScript;
7328 use crate::ln::chan_utils;
7329 use crate::ln::chan_utils::{htlc_success_tx_weight, htlc_timeout_tx_weight};
7330 use crate::chain::BestBlock;
7331 use crate::chain::chaininterface::{FeeEstimator, LowerBoundedFeeEstimator, ConfirmationTarget};
7332 use crate::sign::{ChannelSigner, InMemorySigner, EntropySource, SignerProvider};
7333 use crate::chain::transaction::OutPoint;
7334 use crate::routing::router::Path;
7335 use crate::util::config::UserConfig;
7336 use crate::util::enforcing_trait_impls::EnforcingSigner;
7337 use crate::util::errors::APIError;
7338 use crate::util::test_utils;
7339 use crate::util::test_utils::OnGetShutdownScriptpubkey;
7340 use bitcoin::secp256k1::{Secp256k1, ecdsa::Signature};
7341 use bitcoin::secp256k1::ffi::Signature as FFISignature;
7342 use bitcoin::secp256k1::{SecretKey,PublicKey};
7343 use bitcoin::hashes::sha256::Hash as Sha256;
7344 use bitcoin::hashes::Hash;
7345 use bitcoin::hash_types::WPubkeyHash;
7346 use bitcoin::PackedLockTime;
7347 use bitcoin::util::address::WitnessVersion;
7348 use crate::prelude::*;
7350 struct TestFeeEstimator {
7353 impl FeeEstimator for TestFeeEstimator {
7354 fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u32 {
7360 fn test_max_funding_satoshis_no_wumbo() {
7361 assert_eq!(TOTAL_BITCOIN_SUPPLY_SATOSHIS, 21_000_000 * 100_000_000);
7362 assert!(MAX_FUNDING_SATOSHIS_NO_WUMBO <= TOTAL_BITCOIN_SUPPLY_SATOSHIS,
7363 "MAX_FUNDING_SATOSHIS_NO_WUMBO is greater than all satoshis in existence");
7367 fn test_no_fee_check_overflow() {
7368 // Previously, calling `check_remote_fee` with a fee of 0xffffffff would overflow in
7369 // arithmetic, causing a panic with debug assertions enabled.
7370 let fee_est = TestFeeEstimator { fee_est: 42 };
7371 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
7372 assert!(Channel::<InMemorySigner>::check_remote_fee(&bounded_fee_estimator,
7373 u32::max_value(), None, &&test_utils::TestLogger::new()).is_err());
7377 signer: InMemorySigner,
7380 impl EntropySource for Keys {
7381 fn get_secure_random_bytes(&self) -> [u8; 32] { [0; 32] }
7384 impl SignerProvider for Keys {
7385 type Signer = InMemorySigner;
7387 fn generate_channel_keys_id(&self, _inbound: bool, _channel_value_satoshis: u64, _user_channel_id: u128) -> [u8; 32] {
7388 self.signer.channel_keys_id()
7391 fn derive_channel_signer(&self, _channel_value_satoshis: u64, _channel_keys_id: [u8; 32]) -> Self::Signer {
7395 fn read_chan_signer(&self, _data: &[u8]) -> Result<Self::Signer, DecodeError> { panic!(); }
7397 fn get_destination_script(&self) -> Result<Script, ()> {
7398 let secp_ctx = Secp256k1::signing_only();
7399 let channel_monitor_claim_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
7400 let channel_monitor_claim_key_hash = WPubkeyHash::hash(&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize());
7401 Ok(Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&channel_monitor_claim_key_hash[..]).into_script())
7404 fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()> {
7405 let secp_ctx = Secp256k1::signing_only();
7406 let channel_close_key = SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap();
7407 Ok(ShutdownScript::new_p2wpkh_from_pubkey(PublicKey::from_secret_key(&secp_ctx, &channel_close_key)))
7411 #[cfg(all(feature = "_test_vectors", not(feature = "grind_signatures")))]
7412 fn public_from_secret_hex(secp_ctx: &Secp256k1<bitcoin::secp256k1::All>, hex: &str) -> PublicKey {
7413 PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&hex::decode(hex).unwrap()[..]).unwrap())
7417 fn upfront_shutdown_script_incompatibility() {
7418 let features = channelmanager::provided_init_features(&UserConfig::default()).clear_shutdown_anysegwit();
7419 let non_v0_segwit_shutdown_script =
7420 ShutdownScript::new_witness_program(WitnessVersion::V16, &[0, 40]).unwrap();
7422 let seed = [42; 32];
7423 let network = Network::Testnet;
7424 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7425 keys_provider.expect(OnGetShutdownScriptpubkey {
7426 returns: non_v0_segwit_shutdown_script.clone(),
7429 let secp_ctx = Secp256k1::new();
7430 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7431 let config = UserConfig::default();
7432 match OutboundV1Channel::<EnforcingSigner>::new(&LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 253 }), &&keys_provider, &&keys_provider, node_id, &features, 10000000, 100000, 42, &config, 0, 42) {
7433 Err(APIError::IncompatibleShutdownScript { script }) => {
7434 assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
7436 Err(e) => panic!("Unexpected error: {:?}", e),
7437 Ok(_) => panic!("Expected error"),
7441 // Check that, during channel creation, we use the same feerate in the open channel message
7442 // as we do in the Channel object creation itself.
7444 fn test_open_channel_msg_fee() {
7445 let original_fee = 253;
7446 let mut fee_est = TestFeeEstimator{fee_est: original_fee };
7447 let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
7448 let secp_ctx = Secp256k1::new();
7449 let seed = [42; 32];
7450 let network = Network::Testnet;
7451 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7453 let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7454 let config = UserConfig::default();
7455 let node_a_chan = OutboundV1Channel::<EnforcingSigner>::new(&bounded_fee_estimator, &&keys_provider, &&keys_provider, node_a_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7457 // Now change the fee so we can check that the fee in the open_channel message is the
7458 // same as the old fee.
7459 fee_est.fee_est = 500;
7460 let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
7461 assert_eq!(open_channel_msg.feerate_per_kw, original_fee);
7465 fn test_holder_vs_counterparty_dust_limit() {
7466 // Test that when calculating the local and remote commitment transaction fees, the correct
7467 // dust limits are used.
7468 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7469 let secp_ctx = Secp256k1::new();
7470 let seed = [42; 32];
7471 let network = Network::Testnet;
7472 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7473 let logger = test_utils::TestLogger::new();
7474 let best_block = BestBlock::from_network(network);
7476 // Go through the flow of opening a channel between two nodes, making sure
7477 // they have different dust limits.
7479 // Create Node A's channel pointing to Node B's pubkey
7480 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7481 let config = UserConfig::default();
7482 let mut node_a_chan = OutboundV1Channel::<EnforcingSigner>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7484 // Create Node B's channel by receiving Node A's open_channel message
7485 // Make sure A's dust limit is as we expect.
7486 let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
7487 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7488 let mut node_b_chan = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7490 // Node B --> Node A: accept channel, explicitly setting B's dust limit.
7491 let mut accept_channel_msg = node_b_chan.accept_inbound_channel(0);
7492 accept_channel_msg.dust_limit_satoshis = 546;
7493 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
7494 node_a_chan.context.holder_dust_limit_satoshis = 1560;
7496 // Node A --> Node B: funding created
7497 let output_script = node_a_chan.context.get_funding_redeemscript();
7498 let tx = Transaction { version: 1, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: vec![TxOut {
7499 value: 10000000, script_pubkey: output_script.clone(),
7501 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
7502 let (mut node_a_chan, funding_created_msg) = node_a_chan.get_outbound_funding_created(tx.clone(), funding_outpoint, &&logger).map_err(|_| ()).unwrap();
7503 let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg, best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
7505 // Node B --> Node A: funding signed
7506 let _ = node_a_chan.funding_signed(&funding_signed_msg, best_block, &&keys_provider, &&logger).unwrap();
7508 // Put some inbound and outbound HTLCs in A's channel.
7509 let htlc_amount_msat = 11_092_000; // put an amount below A's effective dust limit but above B's.
7510 node_a_chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
7512 amount_msat: htlc_amount_msat,
7513 payment_hash: PaymentHash(Sha256::hash(&[42; 32]).into_inner()),
7514 cltv_expiry: 300000000,
7515 state: InboundHTLCState::Committed,
7518 node_a_chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
7520 amount_msat: htlc_amount_msat, // put an amount below A's dust amount but above B's.
7521 payment_hash: PaymentHash(Sha256::hash(&[43; 32]).into_inner()),
7522 cltv_expiry: 200000000,
7523 state: OutboundHTLCState::Committed,
7524 source: HTLCSource::OutboundRoute {
7525 path: Path { hops: Vec::new(), blinded_tail: None },
7526 session_priv: SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
7527 first_hop_htlc_msat: 548,
7528 payment_id: PaymentId([42; 32]),
7530 skimmed_fee_msat: None,
7533 // Make sure when Node A calculates their local commitment transaction, none of the HTLCs pass
7534 // the dust limit check.
7535 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
7536 let local_commit_tx_fee = node_a_chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
7537 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());
7538 assert_eq!(local_commit_tx_fee, local_commit_fee_0_htlcs);
7540 // Finally, make sure that when Node A calculates the remote's commitment transaction fees, all
7541 // of the HTLCs are seen to be above the dust limit.
7542 node_a_chan.context.channel_transaction_parameters.is_outbound_from_holder = false;
7543 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());
7544 let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
7545 let remote_commit_tx_fee = node_a_chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7546 assert_eq!(remote_commit_tx_fee, remote_commit_fee_3_htlcs);
7550 fn test_timeout_vs_success_htlc_dust_limit() {
7551 // Make sure that when `next_remote_commit_tx_fee_msat` and `next_local_commit_tx_fee_msat`
7552 // calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
7553 // *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
7554 // `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
7555 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 253 });
7556 let secp_ctx = Secp256k1::new();
7557 let seed = [42; 32];
7558 let network = Network::Testnet;
7559 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7561 let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7562 let config = UserConfig::default();
7563 let mut chan = OutboundV1Channel::<EnforcingSigner>::new(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7565 let commitment_tx_fee_0_htlcs = commit_tx_fee_msat(chan.context.feerate_per_kw, 0, chan.context.get_channel_type());
7566 let commitment_tx_fee_1_htlc = commit_tx_fee_msat(chan.context.feerate_per_kw, 1, chan.context.get_channel_type());
7568 // If HTLC_SUCCESS_TX_WEIGHT and HTLC_TIMEOUT_TX_WEIGHT were swapped: then this HTLC would be
7569 // counted as dust when it shouldn't be.
7570 let htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.holder_dust_limit_satoshis + 1) * 1000;
7571 let htlc_candidate = HTLCCandidate::new(htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
7572 let commitment_tx_fee = chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
7573 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
7575 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
7576 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;
7577 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_below_success, HTLCInitiator::RemoteOffered);
7578 let commitment_tx_fee = chan.context.next_local_commit_tx_fee_msat(htlc_candidate, None);
7579 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
7581 chan.context.channel_transaction_parameters.is_outbound_from_holder = false;
7583 // If swapped: this HTLC would be counted as non-dust when it shouldn't be.
7584 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;
7585 let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
7586 let commitment_tx_fee = chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7587 assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
7589 // If swapped: this HTLC would be counted as dust when it shouldn't be.
7590 let htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.context.get_channel_type()) / 1000) + chan.context.counterparty_dust_limit_satoshis - 1) * 1000;
7591 let htlc_candidate = HTLCCandidate::new(htlc_amt_below_success, HTLCInitiator::RemoteOffered);
7592 let commitment_tx_fee = chan.context.next_remote_commit_tx_fee_msat(htlc_candidate, None);
7593 assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
7597 fn channel_reestablish_no_updates() {
7598 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7599 let logger = test_utils::TestLogger::new();
7600 let secp_ctx = Secp256k1::new();
7601 let seed = [42; 32];
7602 let network = Network::Testnet;
7603 let best_block = BestBlock::from_network(network);
7604 let chain_hash = best_block.block_hash();
7605 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7607 // Go through the flow of opening a channel between two nodes.
7609 // Create Node A's channel pointing to Node B's pubkey
7610 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7611 let config = UserConfig::default();
7612 let mut node_a_chan = OutboundV1Channel::<EnforcingSigner>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7614 // Create Node B's channel by receiving Node A's open_channel message
7615 let open_channel_msg = node_a_chan.get_open_channel(chain_hash);
7616 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7617 let mut node_b_chan = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7619 // Node B --> Node A: accept channel
7620 let accept_channel_msg = node_b_chan.accept_inbound_channel(0);
7621 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
7623 // Node A --> Node B: funding created
7624 let output_script = node_a_chan.context.get_funding_redeemscript();
7625 let tx = Transaction { version: 1, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: vec![TxOut {
7626 value: 10000000, script_pubkey: output_script.clone(),
7628 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
7629 let (mut node_a_chan, funding_created_msg) = node_a_chan.get_outbound_funding_created(tx.clone(), funding_outpoint, &&logger).map_err(|_| ()).unwrap();
7630 let (mut node_b_chan, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg, best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
7632 // Node B --> Node A: funding signed
7633 let _ = node_a_chan.funding_signed(&funding_signed_msg, best_block, &&keys_provider, &&logger).unwrap();
7635 // Now disconnect the two nodes and check that the commitment point in
7636 // Node B's channel_reestablish message is sane.
7637 node_b_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger);
7638 let msg = node_b_chan.get_channel_reestablish(&&logger);
7639 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
7640 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
7641 assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);
7643 // Check that the commitment point in Node A's channel_reestablish message
7645 node_a_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger);
7646 let msg = node_a_chan.get_channel_reestablish(&&logger);
7647 assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
7648 assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
7649 assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);
7653 fn test_configured_holder_max_htlc_value_in_flight() {
7654 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7655 let logger = test_utils::TestLogger::new();
7656 let secp_ctx = Secp256k1::new();
7657 let seed = [42; 32];
7658 let network = Network::Testnet;
7659 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7660 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7661 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7663 let mut config_2_percent = UserConfig::default();
7664 config_2_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 2;
7665 let mut config_99_percent = UserConfig::default();
7666 config_99_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 99;
7667 let mut config_0_percent = UserConfig::default();
7668 config_0_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 0;
7669 let mut config_101_percent = UserConfig::default();
7670 config_101_percent.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 101;
7672 // Test that `OutboundV1Channel::new` creates a channel with the correct value for
7673 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
7674 // which is set to the lower bound + 1 (2%) of the `channel_value`.
7675 let chan_1 = OutboundV1Channel::<EnforcingSigner>::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();
7676 let chan_1_value_msat = chan_1.context.channel_value_satoshis * 1000;
7677 assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
7679 // Test with the upper bound - 1 of valid values (99%).
7680 let chan_2 = OutboundV1Channel::<EnforcingSigner>::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();
7681 let chan_2_value_msat = chan_2.context.channel_value_satoshis * 1000;
7682 assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
7684 let chan_1_open_channel_msg = chan_1.get_open_channel(genesis_block(network).header.block_hash());
7686 // Test that `InboundV1Channel::new` creates a channel with the correct value for
7687 // `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
7688 // which is set to the lower bound - 1 (2%) of the `channel_value`.
7689 let chan_3 = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7690 let chan_3_value_msat = chan_3.context.channel_value_satoshis * 1000;
7691 assert_eq!(chan_3.context.holder_max_htlc_value_in_flight_msat, (chan_3_value_msat as f64 * 0.02) as u64);
7693 // Test with the upper bound - 1 of valid values (99%).
7694 let chan_4 = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7695 let chan_4_value_msat = chan_4.context.channel_value_satoshis * 1000;
7696 assert_eq!(chan_4.context.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);
7698 // Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
7699 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
7700 let chan_5 = OutboundV1Channel::<EnforcingSigner>::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();
7701 let chan_5_value_msat = chan_5.context.channel_value_satoshis * 1000;
7702 assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
7704 // Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values
7705 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
7707 let chan_6 = OutboundV1Channel::<EnforcingSigner>::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();
7708 let chan_6_value_msat = chan_6.context.channel_value_satoshis * 1000;
7709 assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
7711 // Test that `InboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
7712 // if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
7713 let chan_7 = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7714 let chan_7_value_msat = chan_7.context.channel_value_satoshis * 1000;
7715 assert_eq!(chan_7.context.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);
7717 // Test that `InboundV1Channel::new` uses the upper bound of the configurable percentage values
7718 // (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
7720 let chan_8 = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7721 let chan_8_value_msat = chan_8.context.channel_value_satoshis * 1000;
7722 assert_eq!(chan_8.context.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
7726 fn test_configured_holder_selected_channel_reserve_satoshis() {
7728 // Test that `OutboundV1Channel::new` and `InboundV1Channel::new` create a channel with the correct
7729 // channel reserves, when `their_channel_reserve_proportional_millionths` is configured.
7730 test_self_and_counterparty_channel_reserve(10_000_000, 0.02, 0.02);
7732 // Test with valid but unreasonably high channel reserves
7733 // Requesting and accepting parties have requested for 49%-49% and 60%-30% channel reserve
7734 test_self_and_counterparty_channel_reserve(10_000_000, 0.49, 0.49);
7735 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.30);
7737 // Test with calculated channel reserve less than lower bound
7738 // i.e `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
7739 test_self_and_counterparty_channel_reserve(100_000, 0.00002, 0.30);
7741 // Test with invalid channel reserves since sum of both is greater than or equal
7743 test_self_and_counterparty_channel_reserve(10_000_000, 0.50, 0.50);
7744 test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.50);
7747 fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
7748 let fee_est = LowerBoundedFeeEstimator::new(&TestFeeEstimator { fee_est: 15_000 });
7749 let logger = test_utils::TestLogger::new();
7750 let secp_ctx = Secp256k1::new();
7751 let seed = [42; 32];
7752 let network = Network::Testnet;
7753 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7754 let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7755 let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7758 let mut outbound_node_config = UserConfig::default();
7759 outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
7760 let chan = OutboundV1Channel::<EnforcingSigner>::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();
7762 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);
7763 assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
7765 let chan_open_channel_msg = chan.get_open_channel(genesis_block(network).header.block_hash());
7766 let mut inbound_node_config = UserConfig::default();
7767 inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
7769 if outbound_selected_channel_reserve_perc + inbound_selected_channel_reserve_perc < 1.0 {
7770 let chan_inbound_node = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7772 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);
7774 assert_eq!(chan_inbound_node.context.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
7775 assert_eq!(chan_inbound_node.context.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
7777 // Channel Negotiations failed
7778 let result = InboundV1Channel::<EnforcingSigner>::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, 42);
7779 assert!(result.is_err());
7784 fn channel_update() {
7785 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
7786 let logger = test_utils::TestLogger::new();
7787 let secp_ctx = Secp256k1::new();
7788 let seed = [42; 32];
7789 let network = Network::Testnet;
7790 let best_block = BestBlock::from_network(network);
7791 let chain_hash = genesis_block(network).header.block_hash();
7792 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
7794 // Create Node A's channel pointing to Node B's pubkey
7795 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7796 let config = UserConfig::default();
7797 let mut node_a_chan = OutboundV1Channel::<EnforcingSigner>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
7799 // Create Node B's channel by receiving Node A's open_channel message
7800 // Make sure A's dust limit is as we expect.
7801 let open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
7802 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
7803 let mut node_b_chan = InboundV1Channel::<EnforcingSigner>::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, 42).unwrap();
7805 // Node B --> Node A: accept channel, explicitly setting B's dust limit.
7806 let mut accept_channel_msg = node_b_chan.accept_inbound_channel(0);
7807 accept_channel_msg.dust_limit_satoshis = 546;
7808 node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
7809 node_a_chan.context.holder_dust_limit_satoshis = 1560;
7811 // Node A --> Node B: funding created
7812 let output_script = node_a_chan.context.get_funding_redeemscript();
7813 let tx = Transaction { version: 1, lock_time: PackedLockTime::ZERO, input: Vec::new(), output: vec![TxOut {
7814 value: 10000000, script_pubkey: output_script.clone(),
7816 let funding_outpoint = OutPoint{ txid: tx.txid(), index: 0 };
7817 let (mut node_a_chan, funding_created_msg) = node_a_chan.get_outbound_funding_created(tx.clone(), funding_outpoint, &&logger).map_err(|_| ()).unwrap();
7818 let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg, best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();
7820 // Node B --> Node A: funding signed
7821 let _ = node_a_chan.funding_signed(&funding_signed_msg, best_block, &&keys_provider, &&logger).unwrap();
7823 // Make sure that receiving a channel update will update the Channel as expected.
7824 let update = ChannelUpdate {
7825 contents: UnsignedChannelUpdate {
7827 short_channel_id: 0,
7830 cltv_expiry_delta: 100,
7831 htlc_minimum_msat: 5,
7832 htlc_maximum_msat: MAX_VALUE_MSAT,
7834 fee_proportional_millionths: 11,
7835 excess_data: Vec::new(),
7837 signature: Signature::from(unsafe { FFISignature::new() })
7839 node_a_chan.channel_update(&update).unwrap();
7841 // The counterparty can send an update with a higher minimum HTLC, but that shouldn't
7842 // change our official htlc_minimum_msat.
7843 assert_eq!(node_a_chan.context.holder_htlc_minimum_msat, 1);
7844 match node_a_chan.context.counterparty_forwarding_info() {
7846 assert_eq!(info.cltv_expiry_delta, 100);
7847 assert_eq!(info.fee_base_msat, 110);
7848 assert_eq!(info.fee_proportional_millionths, 11);
7850 None => panic!("expected counterparty forwarding info to be Some")
7854 #[cfg(feature = "_test_vectors")]
7856 fn outbound_commitment_test() {
7857 use bitcoin::util::sighash;
7858 use bitcoin::consensus::encode::serialize;
7859 use bitcoin::blockdata::transaction::EcdsaSighashType;
7860 use bitcoin::hashes::hex::FromHex;
7861 use bitcoin::hash_types::Txid;
7862 use bitcoin::secp256k1::Message;
7863 use crate::sign::EcdsaChannelSigner;
7864 use crate::ln::PaymentPreimage;
7865 use crate::ln::channel::{HTLCOutputInCommitment ,TxCreationKeys};
7866 use crate::ln::chan_utils::{ChannelPublicKeys, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters};
7867 use crate::util::logger::Logger;
7868 use crate::sync::Arc;
7870 // Test vectors from BOLT 3 Appendices C and F (anchors):
7871 let feeest = TestFeeEstimator{fee_est: 15000};
7872 let logger : Arc<Logger> = Arc::new(test_utils::TestLogger::new());
7873 let secp_ctx = Secp256k1::new();
7875 let mut signer = InMemorySigner::new(
7877 SecretKey::from_slice(&hex::decode("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749").unwrap()[..]).unwrap(),
7878 SecretKey::from_slice(&hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
7879 SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
7880 SecretKey::from_slice(&hex::decode("3333333333333333333333333333333333333333333333333333333333333333").unwrap()[..]).unwrap(),
7881 SecretKey::from_slice(&hex::decode("1111111111111111111111111111111111111111111111111111111111111111").unwrap()[..]).unwrap(),
7883 // These aren't set in the test vectors:
7884 [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],
7890 assert_eq!(signer.pubkeys().funding_pubkey.serialize()[..],
7891 hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
7892 let keys_provider = Keys { signer: signer.clone() };
7894 let counterparty_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
7895 let mut config = UserConfig::default();
7896 config.channel_handshake_config.announced_channel = false;
7897 let mut chan = OutboundV1Channel::<InMemorySigner>::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
7898 chan.context.holder_dust_limit_satoshis = 546;
7899 chan.context.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
7901 let funding_info = OutPoint{ txid: Txid::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), index: 0 };
7903 let counterparty_pubkeys = ChannelPublicKeys {
7904 funding_pubkey: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
7905 revocation_basepoint: PublicKey::from_slice(&hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap(),
7906 payment_point: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444"),
7907 delayed_payment_basepoint: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
7908 htlc_basepoint: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444")
7910 chan.context.channel_transaction_parameters.counterparty_parameters = Some(
7911 CounterpartyChannelTransactionParameters {
7912 pubkeys: counterparty_pubkeys.clone(),
7913 selected_contest_delay: 144
7915 chan.context.channel_transaction_parameters.funding_outpoint = Some(funding_info);
7916 signer.provide_channel_parameters(&chan.context.channel_transaction_parameters);
7918 assert_eq!(counterparty_pubkeys.payment_point.serialize()[..],
7919 hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
7921 assert_eq!(counterparty_pubkeys.funding_pubkey.serialize()[..],
7922 hex::decode("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1").unwrap()[..]);
7924 assert_eq!(counterparty_pubkeys.htlc_basepoint.serialize()[..],
7925 hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
7927 // We can't just use build_holder_transaction_keys here as the per_commitment_secret is not
7928 // derived from a commitment_seed, so instead we copy it here and call
7929 // build_commitment_transaction.
7930 let delayed_payment_base = &chan.context.holder_signer.pubkeys().delayed_payment_basepoint;
7931 let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
7932 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
7933 let htlc_basepoint = &chan.context.holder_signer.pubkeys().htlc_basepoint;
7934 let keys = TxCreationKeys::derive_new(&secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint);
7936 macro_rules! test_commitment {
7937 ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
7938 chan.context.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::only_static_remote_key();
7939 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::only_static_remote_key(), $($remain)*);
7943 macro_rules! test_commitment_with_anchors {
7944 ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
7945 chan.context.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
7946 test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(), $($remain)*);
7950 macro_rules! test_commitment_common {
7951 ( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $opt_anchors: expr, {
7952 $( { $htlc_idx: expr, $counterparty_htlc_sig_hex: expr, $htlc_sig_hex: expr, $htlc_tx_hex: expr } ), *
7954 let (commitment_tx, htlcs): (_, Vec<HTLCOutputInCommitment>) = {
7955 let mut commitment_stats = chan.context.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false, &logger);
7957 let htlcs = commitment_stats.htlcs_included.drain(..)
7958 .filter_map(|(htlc, _)| if htlc.transaction_output_index.is_some() { Some(htlc) } else { None })
7960 (commitment_stats.tx, htlcs)
7962 let trusted_tx = commitment_tx.trust();
7963 let unsigned_tx = trusted_tx.built_transaction();
7964 let redeemscript = chan.context.get_funding_redeemscript();
7965 let counterparty_signature = Signature::from_der(&hex::decode($counterparty_sig_hex).unwrap()[..]).unwrap();
7966 let sighash = unsigned_tx.get_sighash_all(&redeemscript, chan.context.channel_value_satoshis);
7967 log_trace!(logger, "unsigned_tx = {}", hex::encode(serialize(&unsigned_tx.transaction)));
7968 assert!(secp_ctx.verify_ecdsa(&sighash, &counterparty_signature, chan.context.counterparty_funding_pubkey()).is_ok(), "verify counterparty commitment sig");
7970 let mut per_htlc: Vec<(HTLCOutputInCommitment, Option<Signature>)> = Vec::new();
7971 per_htlc.clear(); // Don't warn about excess mut for no-HTLC calls
7972 let mut counterparty_htlc_sigs = Vec::new();
7973 counterparty_htlc_sigs.clear(); // Don't warn about excess mut for no-HTLC calls
7975 let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
7976 per_htlc.push((htlcs[$htlc_idx].clone(), Some(remote_signature)));
7977 counterparty_htlc_sigs.push(remote_signature);
7979 assert_eq!(htlcs.len(), per_htlc.len());
7981 let holder_commitment_tx = HolderCommitmentTransaction::new(
7982 commitment_tx.clone(),
7983 counterparty_signature,
7984 counterparty_htlc_sigs,
7985 &chan.context.holder_signer.pubkeys().funding_pubkey,
7986 chan.context.counterparty_funding_pubkey()
7988 let (holder_sig, htlc_sigs) = signer.sign_holder_commitment_and_htlcs(&holder_commitment_tx, &secp_ctx).unwrap();
7989 assert_eq!(Signature::from_der(&hex::decode($sig_hex).unwrap()[..]).unwrap(), holder_sig, "holder_sig");
7991 let funding_redeemscript = chan.context.get_funding_redeemscript();
7992 let tx = holder_commitment_tx.add_holder_sig(&funding_redeemscript, holder_sig);
7993 assert_eq!(serialize(&tx)[..], hex::decode($tx_hex).unwrap()[..], "tx");
7995 // ((htlc, counterparty_sig), (index, holder_sig))
7996 let mut htlc_sig_iter = holder_commitment_tx.htlcs().iter().zip(&holder_commitment_tx.counterparty_htlc_sigs).zip(htlc_sigs.iter().enumerate());
7999 log_trace!(logger, "verifying htlc {}", $htlc_idx);
8000 let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
8002 let ref htlc = htlcs[$htlc_idx];
8003 let htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, chan.context.feerate_per_kw,
8004 chan.context.get_counterparty_selected_contest_delay().unwrap(),
8005 &htlc, $opt_anchors, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
8006 let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, $opt_anchors, &keys);
8007 let htlc_sighashtype = if $opt_anchors.supports_anchors_zero_fee_htlc_tx() { EcdsaSighashType::SinglePlusAnyoneCanPay } else { EcdsaSighashType::All };
8008 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();
8009 assert!(secp_ctx.verify_ecdsa(&htlc_sighash, &remote_signature, &keys.countersignatory_htlc_key).is_ok(), "verify counterparty htlc sig");
8011 let mut preimage: Option<PaymentPreimage> = None;
8014 let out = PaymentHash(Sha256::hash(&[i; 32]).into_inner());
8015 if out == htlc.payment_hash {
8016 preimage = Some(PaymentPreimage([i; 32]));
8020 assert!(preimage.is_some());
8023 let htlc_sig = htlc_sig_iter.next().unwrap();
8024 let num_anchors = if $opt_anchors.supports_anchors_zero_fee_htlc_tx() { 2 } else { 0 };
8025 assert_eq!((htlc_sig.0).0.transaction_output_index, Some($htlc_idx + num_anchors), "output index");
8027 let signature = Signature::from_der(&hex::decode($htlc_sig_hex).unwrap()[..]).unwrap();
8028 assert_eq!(signature, *(htlc_sig.1).1, "htlc sig");
8029 let index = (htlc_sig.1).0;
8030 let channel_parameters = chan.context.channel_transaction_parameters.as_holder_broadcastable();
8031 let trusted_tx = holder_commitment_tx.trust();
8032 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))));
8033 assert_eq!(serialize(&trusted_tx.get_signed_htlc_tx(&channel_parameters, index, &(htlc_sig.0).1, (htlc_sig.1).1, &preimage))[..],
8034 hex::decode($htlc_tx_hex).unwrap()[..], "htlc tx");
8036 assert!(htlc_sig_iter.next().is_none());
8040 // anchors: simple commitment tx with no HTLCs and single anchor
8041 test_commitment_with_anchors!("30440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a8658",
8042 "3044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778",
8043 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8045 // simple commitment tx with no HTLCs
8046 chan.context.value_to_self_msat = 7000000000;
8048 test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
8049 "30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
8050 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48454a56a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004730440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae05564714201483045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8052 // anchors: simple commitment tx with no HTLCs
8053 test_commitment_with_anchors!("3045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f3",
8054 "30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
8055 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8057 chan.context.pending_inbound_htlcs.push({
8058 let mut out = InboundHTLCOutput{
8060 amount_msat: 1000000,
8062 payment_hash: PaymentHash([0; 32]),
8063 state: InboundHTLCState::Committed,
8065 out.payment_hash.0 = Sha256::hash(&hex::decode("0000000000000000000000000000000000000000000000000000000000000000").unwrap()).into_inner();
8068 chan.context.pending_inbound_htlcs.push({
8069 let mut out = InboundHTLCOutput{
8071 amount_msat: 2000000,
8073 payment_hash: PaymentHash([0; 32]),
8074 state: InboundHTLCState::Committed,
8076 out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
8079 chan.context.pending_outbound_htlcs.push({
8080 let mut out = OutboundHTLCOutput{
8082 amount_msat: 2000000,
8084 payment_hash: PaymentHash([0; 32]),
8085 state: OutboundHTLCState::Committed,
8086 source: HTLCSource::dummy(),
8087 skimmed_fee_msat: None,
8089 out.payment_hash.0 = Sha256::hash(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()).into_inner();
8092 chan.context.pending_outbound_htlcs.push({
8093 let mut out = OutboundHTLCOutput{
8095 amount_msat: 3000000,
8097 payment_hash: PaymentHash([0; 32]),
8098 state: OutboundHTLCState::Committed,
8099 source: HTLCSource::dummy(),
8100 skimmed_fee_msat: None,
8102 out.payment_hash.0 = Sha256::hash(&hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()).into_inner();
8105 chan.context.pending_inbound_htlcs.push({
8106 let mut out = InboundHTLCOutput{
8108 amount_msat: 4000000,
8110 payment_hash: PaymentHash([0; 32]),
8111 state: InboundHTLCState::Committed,
8113 out.payment_hash.0 = Sha256::hash(&hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()).into_inner();
8117 // commitment tx with all five HTLCs untrimmed (minimum feerate)
8118 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8119 chan.context.feerate_per_kw = 0;
8121 test_commitment!("3044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e5",
8122 "304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea",
8123 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e0a06a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea01473044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8126 "3045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b",
8127 "30440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce",
8128 "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b00000000000000000001e8030000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b014730440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
8131 "30440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f896004",
8132 "3045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f",
8133 "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b01000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f89600401483045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8136 "30440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d43352",
8137 "3045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa",
8138 "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b02000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d4335201483045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8141 "304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c1363",
8142 "304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac7487",
8143 "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b03000000000000000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c13630147304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac748701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8146 "3044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b87",
8147 "3045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95",
8148 "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b04000000000000000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b8701483045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8151 // commitment tx with seven outputs untrimmed (maximum feerate)
8152 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8153 chan.context.feerate_per_kw = 647;
8155 test_commitment!("3045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee",
8156 "30450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb7",
8157 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e09c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb701483045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8160 "30450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f",
8161 "30440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b",
8162 "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f014730440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000" },
8165 "304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c",
8166 "30450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f",
8167 "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0100000000000000000124060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c014830450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8170 "30440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c8",
8171 "3045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673",
8172 "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe020000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c801483045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8175 "304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c64",
8176 "3045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee",
8177 "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe030000000000000000010c0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c6401483045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8180 "30450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca",
8181 "3044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9",
8182 "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe04000000000000000001da0d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca01473044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8185 // commitment tx with six outputs untrimmed (minimum feerate)
8186 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8187 chan.context.feerate_per_kw = 648;
8189 test_commitment!("304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e5",
8190 "3045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e9",
8191 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4844e9d6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e90147304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8194 "3045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e0",
8195 "304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec6",
8196 "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10000000000000000000123060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e00148304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8199 "304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d384124",
8200 "3044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae",
8201 "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10100000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d38412401473044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8204 "304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc625532989",
8205 "3045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e2260796",
8206 "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf1020000000000000000010b0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc62553298901483045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e226079601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8209 "3044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be",
8210 "3045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6",
8211 "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf103000000000000000001d90d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be01483045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8214 // anchors: commitment tx with six outputs untrimmed (minimum dust limit)
8215 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8216 chan.context.feerate_per_kw = 645;
8217 chan.context.holder_dust_limit_satoshis = 1001;
8219 test_commitment_with_anchors!("3044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc312",
8220 "3045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d0051",
8221 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80084a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d0070000000000002200203e68115ae0b15b8de75b6c6bc9af5ac9f01391544e0870dae443a1e8fe7837ead007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5eb80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994abc996a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d005101473044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc31201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8224 "3045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc282",
8225 "3045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef09",
8226 "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320002000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc28283483045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef0901008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6851b27568f6010000" },
8229 "3045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e",
8230 "3045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac",
8231 "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320003000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e83483045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
8234 "3044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c1",
8235 "304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e",
8236 "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320004000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c18347304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
8239 "3044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc615",
8240 "3045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226",
8241 "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320005000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc61583483045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
8244 // commitment tx with six outputs untrimmed (maximum feerate)
8245 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8246 chan.context.feerate_per_kw = 2069;
8247 chan.context.holder_dust_limit_satoshis = 546;
8249 test_commitment!("304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc",
8250 "3045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e33",
8251 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48477956a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e330148304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8254 "3045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f699",
8255 "3045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d",
8256 "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0000000000000000000175020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f69901483045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8259 "3045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df",
8260 "3045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61",
8261 "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0100000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df01483045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8264 "3045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e0",
8265 "3044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c18",
8266 "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d020000000000000000015d060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e001473044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c1801008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8269 "304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df",
8270 "3045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33",
8271 "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d03000000000000000001f2090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df01483045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8274 // commitment tx with five outputs untrimmed (minimum feerate)
8275 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8276 chan.context.feerate_per_kw = 2070;
8278 test_commitment!("304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c",
8279 "3044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c1",
8280 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484da966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c10147304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8283 "304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b",
8284 "30440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e5",
8285 "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff0000000000000000000174020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b014730440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e501008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8288 "3045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546",
8289 "30450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c6",
8290 "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff010000000000000000015c060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546014830450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8293 "3045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504",
8294 "30440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502",
8295 "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff02000000000000000001f1090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504014730440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8298 // commitment tx with five outputs untrimmed (maximum feerate)
8299 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8300 chan.context.feerate_per_kw = 2194;
8302 test_commitment!("304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb3",
8303 "3044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d398",
8304 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48440966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d3980147304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8307 "3045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de8450",
8308 "304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e0154301",
8309 "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de84500148304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e015430101008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000" },
8312 "3044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a0",
8313 "3045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b77",
8314 "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd010000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a001483045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b7701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8317 "3045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b",
8318 "30450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3",
8319 "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd020000000000000000019a090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b014830450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8322 // commitment tx with four outputs untrimmed (minimum feerate)
8323 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8324 chan.context.feerate_per_kw = 2195;
8326 test_commitment!("304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce403",
8327 "3044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d1767",
8328 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484b8976a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d17670147304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce40301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8331 "3045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e",
8332 "3045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d76",
8333 "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900000000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e01483045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d7601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8336 "3045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a",
8337 "3044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82",
8338 "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900100000000000000000199090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a01473044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8341 // anchors: commitment tx with four outputs untrimmed (minimum dust limit)
8342 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8343 chan.context.feerate_per_kw = 2185;
8344 chan.context.holder_dust_limit_satoshis = 2001;
8345 let cached_channel_type = chan.context.channel_type;
8346 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
8348 test_commitment_with_anchors!("3044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c0",
8349 "3045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd5",
8350 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80064a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994b80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ac5916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd501473044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8353 "304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb",
8354 "30440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f",
8355 "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc02000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb834730440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000" },
8358 "3045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd7271",
8359 "3045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688",
8360 "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc03000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd727183483045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
8363 // commitment tx with four outputs untrimmed (maximum feerate)
8364 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8365 chan.context.feerate_per_kw = 3702;
8366 chan.context.holder_dust_limit_satoshis = 546;
8367 chan.context.channel_type = cached_channel_type.clone();
8369 test_commitment!("304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee40169",
8370 "3045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf75",
8371 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4846f916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf750148304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee4016901475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8374 "304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb89",
8375 "304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f",
8376 "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb890147304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000" },
8379 "3044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb5817",
8380 "304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc",
8381 "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0100000000000000000176050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb58170147304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8384 // commitment tx with three outputs untrimmed (minimum feerate)
8385 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8386 chan.context.feerate_per_kw = 3703;
8388 test_commitment!("3045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e",
8389 "304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e1",
8390 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484eb936a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e101483045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8393 "3045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a",
8394 "3045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05",
8395 "0200000000010120060e4a29579d429f0f27c17ee5f1ee282f20d706d6f90b63d35946d8f3029a0000000000000000000175050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a01483045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8398 // anchors: commitment tx with three outputs untrimmed (minimum dust limit)
8399 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8400 chan.context.feerate_per_kw = 3687;
8401 chan.context.holder_dust_limit_satoshis = 3001;
8402 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
8404 test_commitment_with_anchors!("3045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c228377",
8405 "3045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d",
8406 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80054a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aa28b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d01483045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c22837701475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8409 "3044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c",
8410 "3045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de",
8411 "02000000000101542562b326c08e3a076d9cfca2be175041366591da334d8d513ff1686fd95a6002000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c83483045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000" }
8414 // commitment tx with three outputs untrimmed (maximum feerate)
8415 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8416 chan.context.feerate_per_kw = 4914;
8417 chan.context.holder_dust_limit_satoshis = 546;
8418 chan.context.channel_type = cached_channel_type.clone();
8420 test_commitment!("3045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c95244",
8421 "3045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c19",
8422 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484ae8f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c1901483045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c9524401475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8425 "3045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374",
8426 "30440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10",
8427 "02000000000101a9172908eace869cc35128c31fc2ab502f72e4dff31aab23e0244c4b04b11ab00000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374014730440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000" }
8430 // commitment tx with two outputs untrimmed (minimum feerate)
8431 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8432 chan.context.feerate_per_kw = 4915;
8433 chan.context.holder_dust_limit_satoshis = 546;
8435 test_commitment!("304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a720",
8436 "30450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf5",
8437 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484fa926a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf50147304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a72001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8439 // anchors: commitment tx with two outputs untrimmed (minimum dust limit)
8440 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8441 chan.context.feerate_per_kw = 4894;
8442 chan.context.holder_dust_limit_satoshis = 4001;
8443 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
8445 test_commitment_with_anchors!("3045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b95",
8446 "30450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd",
8447 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ad0886a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd01483045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b9501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8449 // commitment tx with two outputs untrimmed (maximum feerate)
8450 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8451 chan.context.feerate_per_kw = 9651180;
8452 chan.context.holder_dust_limit_satoshis = 546;
8453 chan.context.channel_type = cached_channel_type.clone();
8455 test_commitment!("304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd3",
8456 "3045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de",
8457 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b800222020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80ec0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4840400483045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de0147304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8459 // commitment tx with one output untrimmed (minimum feerate)
8460 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8461 chan.context.feerate_per_kw = 9651181;
8463 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
8464 "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
8465 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8467 // anchors: commitment tx with one output untrimmed (minimum dust limit)
8468 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8469 chan.context.feerate_per_kw = 6216010;
8470 chan.context.holder_dust_limit_satoshis = 4001;
8471 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
8473 test_commitment_with_anchors!("30450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf",
8474 "30450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1",
8475 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a04004830450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1014830450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8477 // commitment tx with fee greater than funder amount
8478 chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
8479 chan.context.feerate_per_kw = 9651936;
8480 chan.context.holder_dust_limit_satoshis = 546;
8481 chan.context.channel_type = cached_channel_type;
8483 test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
8484 "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
8485 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
8487 // commitment tx with 3 htlc outputs, 2 offered having the same amount and preimage
8488 chan.context.value_to_self_msat = 7_000_000_000 - 2_000_000;
8489 chan.context.feerate_per_kw = 253;
8490 chan.context.pending_inbound_htlcs.clear();
8491 chan.context.pending_inbound_htlcs.push({
8492 let mut out = InboundHTLCOutput{
8494 amount_msat: 2000000,
8496 payment_hash: PaymentHash([0; 32]),
8497 state: InboundHTLCState::Committed,
8499 out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
8502 chan.context.pending_outbound_htlcs.clear();
8503 chan.context.pending_outbound_htlcs.push({
8504 let mut out = OutboundHTLCOutput{
8506 amount_msat: 5000001,
8508 payment_hash: PaymentHash([0; 32]),
8509 state: OutboundHTLCState::Committed,
8510 source: HTLCSource::dummy(),
8511 skimmed_fee_msat: None,
8513 out.payment_hash.0 = Sha256::hash(&hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).into_inner();
8516 chan.context.pending_outbound_htlcs.push({
8517 let mut out = OutboundHTLCOutput{
8519 amount_msat: 5000000,
8521 payment_hash: PaymentHash([0; 32]),
8522 state: OutboundHTLCState::Committed,
8523 source: HTLCSource::dummy(),
8524 skimmed_fee_msat: None,
8526 out.payment_hash.0 = Sha256::hash(&hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).into_inner();
8530 test_commitment!("304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c8",
8531 "304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c",
8532 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2d8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121b8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121bc0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484a69f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c0147304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8535 "3045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce5",
8536 "3044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b",
8537 "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec000000000000000000011f070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce501473044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000" },
8539 "3045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a",
8540 "3045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d",
8541 "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec01000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a01483045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868f9010000" },
8543 "30440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc",
8544 "304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb",
8545 "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec02000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc0147304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868fa010000" }
8548 chan.context.channel_type = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
8549 test_commitment_with_anchors!("3044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c725",
8550 "3045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b76",
8551 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80074a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5e881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aad9c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b7601473044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c72501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {
8554 "30440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c2",
8555 "304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424",
8556 "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c402000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c28347304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000" },
8558 "304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c",
8559 "304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b",
8560 "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40300000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c8347304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568f9010000" },
8562 "3045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a1",
8563 "3045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b",
8564 "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40400000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a183483045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568fa010000" }
8569 fn test_per_commitment_secret_gen() {
8570 // Test vectors from BOLT 3 Appendix D:
8572 let mut seed = [0; 32];
8573 seed[0..32].clone_from_slice(&hex::decode("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
8574 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
8575 hex::decode("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]);
8577 seed[0..32].clone_from_slice(&hex::decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap());
8578 assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
8579 hex::decode("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]);
8581 assert_eq!(chan_utils::build_commitment_secret(&seed, 0xaaaaaaaaaaa),
8582 hex::decode("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]);
8584 assert_eq!(chan_utils::build_commitment_secret(&seed, 0x555555555555),
8585 hex::decode("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]);
8587 seed[0..32].clone_from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap());
8588 assert_eq!(chan_utils::build_commitment_secret(&seed, 1),
8589 hex::decode("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]);
8593 fn test_key_derivation() {
8594 // Test vectors from BOLT 3 Appendix E:
8595 let secp_ctx = Secp256k1::new();
8597 let base_secret = SecretKey::from_slice(&hex::decode("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap();
8598 let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
8600 let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret);
8601 assert_eq!(base_point.serialize()[..], hex::decode("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]);
8603 let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
8604 assert_eq!(per_commitment_point.serialize()[..], hex::decode("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]);
8606 assert_eq!(chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &base_point).serialize()[..],
8607 hex::decode("0235f2dbfaa89b57ec7b055afe29849ef7ddfeb1cefdb9ebdc43f5494984db29e5").unwrap()[..]);
8609 assert_eq!(chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &base_secret),
8610 SecretKey::from_slice(&hex::decode("cbced912d3b21bf196a766651e436aff192362621ce317704ea2f75d87e7be0f").unwrap()[..]).unwrap());
8612 assert_eq!(chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &base_point).serialize()[..],
8613 hex::decode("02916e326636d19c33f13e8c0c3a03dd157f332f3e99c317c141dd865eb01f8ff0").unwrap()[..]);
8615 assert_eq!(chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_secret, &base_secret),
8616 SecretKey::from_slice(&hex::decode("d09ffff62ddb2297ab000cc85bcb4283fdeb6aa052affbc9dddcf33b61078110").unwrap()[..]).unwrap());
8620 fn test_zero_conf_channel_type_support() {
8621 let feeest = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8622 let secp_ctx = Secp256k1::new();
8623 let seed = [42; 32];
8624 let network = Network::Testnet;
8625 let keys_provider = test_utils::TestKeysInterface::new(&seed, network);
8626 let logger = test_utils::TestLogger::new();
8628 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
8629 let config = UserConfig::default();
8630 let node_a_chan = OutboundV1Channel::<EnforcingSigner>::new(&feeest, &&keys_provider, &&keys_provider,
8631 node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
8633 let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
8634 channel_type_features.set_zero_conf_required();
8636 let mut open_channel_msg = node_a_chan.get_open_channel(genesis_block(network).header.block_hash());
8637 open_channel_msg.channel_type = Some(channel_type_features);
8638 let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
8639 let res = InboundV1Channel::<EnforcingSigner>::new(&feeest, &&keys_provider, &&keys_provider,
8640 node_b_node_id, &channelmanager::provided_channel_type_features(&config),
8641 &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, 42);
8642 assert!(res.is_ok());
8646 fn test_supports_anchors_zero_htlc_tx_fee() {
8647 // Tests that if both sides support and negotiate `anchors_zero_fee_htlc_tx`, it is the
8648 // resulting `channel_type`.
8649 let secp_ctx = Secp256k1::new();
8650 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8651 let network = Network::Testnet;
8652 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8653 let logger = test_utils::TestLogger::new();
8655 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8656 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8658 let mut config = UserConfig::default();
8659 config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
8661 // It is not enough for just the initiator to signal `option_anchors_zero_fee_htlc_tx`, both
8662 // need to signal it.
8663 let channel_a = OutboundV1Channel::<EnforcingSigner>::new(
8664 &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8665 &channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42,
8668 assert!(!channel_a.context.channel_type.supports_anchors_zero_fee_htlc_tx());
8670 let mut expected_channel_type = ChannelTypeFeatures::empty();
8671 expected_channel_type.set_static_remote_key_required();
8672 expected_channel_type.set_anchors_zero_fee_htlc_tx_required();
8674 let channel_a = OutboundV1Channel::<EnforcingSigner>::new(
8675 &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8676 &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8679 let open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8680 let channel_b = InboundV1Channel::<EnforcingSigner>::new(
8681 &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8682 &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
8683 &open_channel_msg, 7, &config, 0, &&logger, 42
8686 assert_eq!(channel_a.context.channel_type, expected_channel_type);
8687 assert_eq!(channel_b.context.channel_type, expected_channel_type);
8691 fn test_rejects_implicit_simple_anchors() {
8692 // Tests that if `option_anchors` is being negotiated implicitly through the intersection of
8693 // each side's `InitFeatures`, it is rejected.
8694 let secp_ctx = Secp256k1::new();
8695 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8696 let network = Network::Testnet;
8697 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8698 let logger = test_utils::TestLogger::new();
8700 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8701 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8703 let config = UserConfig::default();
8705 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
8706 let static_remote_key_required: u64 = 1 << 12;
8707 let simple_anchors_required: u64 = 1 << 20;
8708 let raw_init_features = static_remote_key_required | simple_anchors_required;
8709 let init_features_with_simple_anchors = InitFeatures::from_le_bytes(raw_init_features.to_le_bytes().to_vec());
8711 let channel_a = OutboundV1Channel::<EnforcingSigner>::new(
8712 &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8713 &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8716 // Set `channel_type` to `None` to force the implicit feature negotiation.
8717 let mut open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8718 open_channel_msg.channel_type = None;
8720 // Since A supports both `static_remote_key` and `option_anchors`, but B only accepts
8721 // `static_remote_key`, it will fail the channel.
8722 let channel_b = InboundV1Channel::<EnforcingSigner>::new(
8723 &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8724 &channelmanager::provided_channel_type_features(&config), &init_features_with_simple_anchors,
8725 &open_channel_msg, 7, &config, 0, &&logger, 42
8727 assert!(channel_b.is_err());
8731 fn test_rejects_simple_anchors_channel_type() {
8732 // Tests that if `option_anchors` is being negotiated through the `channel_type` feature,
8734 let secp_ctx = Secp256k1::new();
8735 let fee_estimator = LowerBoundedFeeEstimator::new(&TestFeeEstimator{fee_est: 15000});
8736 let network = Network::Testnet;
8737 let keys_provider = test_utils::TestKeysInterface::new(&[42; 32], network);
8738 let logger = test_utils::TestLogger::new();
8740 let node_id_a = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[1; 32]).unwrap());
8741 let node_id_b = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[2; 32]).unwrap());
8743 let config = UserConfig::default();
8745 // See feature bit assignments: https://github.com/lightning/bolts/blob/master/09-features.md
8746 let static_remote_key_required: u64 = 1 << 12;
8747 let simple_anchors_required: u64 = 1 << 20;
8748 let simple_anchors_raw_features = static_remote_key_required | simple_anchors_required;
8749 let simple_anchors_init = InitFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
8750 let simple_anchors_channel_type = ChannelTypeFeatures::from_le_bytes(simple_anchors_raw_features.to_le_bytes().to_vec());
8751 assert!(!simple_anchors_init.requires_unknown_bits());
8752 assert!(!simple_anchors_channel_type.requires_unknown_bits());
8754 // First, we'll try to open a channel between A and B where A requests a channel type for
8755 // the original `option_anchors` feature (non zero fee htlc tx). This should be rejected by
8756 // B as it's not supported by LDK.
8757 let channel_a = OutboundV1Channel::<EnforcingSigner>::new(
8758 &fee_estimator, &&keys_provider, &&keys_provider, node_id_b,
8759 &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42
8762 let mut open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8763 open_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
8765 let res = InboundV1Channel::<EnforcingSigner>::new(
8766 &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8767 &channelmanager::provided_channel_type_features(&config), &simple_anchors_init,
8768 &open_channel_msg, 7, &config, 0, &&logger, 42
8770 assert!(res.is_err());
8772 // Then, we'll try to open another channel where A requests a channel type for
8773 // `anchors_zero_fee_htlc_tx`. B is malicious and tries to downgrade the channel type to the
8774 // original `option_anchors` feature, which should be rejected by A as it's not supported by
8776 let mut channel_a = OutboundV1Channel::<EnforcingSigner>::new(
8777 &fee_estimator, &&keys_provider, &&keys_provider, node_id_b, &simple_anchors_init,
8778 10000000, 100000, 42, &config, 0, 42
8781 let open_channel_msg = channel_a.get_open_channel(genesis_block(network).header.block_hash());
8783 let channel_b = InboundV1Channel::<EnforcingSigner>::new(
8784 &fee_estimator, &&keys_provider, &&keys_provider, node_id_a,
8785 &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config),
8786 &open_channel_msg, 7, &config, 0, &&logger, 42
8789 let mut accept_channel_msg = channel_b.get_accept_channel_message();
8790 accept_channel_msg.channel_type = Some(simple_anchors_channel_type.clone());
8792 let res = channel_a.accept_channel(
8793 &accept_channel_msg, &config.channel_handshake_limits, &simple_anchors_init
8795 assert!(res.is_err());