lightning/ln/

channel.rs

// This file is Copyright its original authors, visible in version control
// history.
//
// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// You may not use this file except in accordance with one or both of these
// licenses.

use bitcoin::absolute::LockTime;
use bitcoin::amount::{Amount, SignedAmount};
use bitcoin::consensus::encode;
use bitcoin::constants::ChainHash;
use bitcoin::script::{Builder, Script, ScriptBuf};
use bitcoin::sighash::EcdsaSighashType;
use bitcoin::transaction::{Transaction, TxOut};
use bitcoin::Witness;

use bitcoin::hash_types::{BlockHash, Txid};
use bitcoin::hashes::sha256::Hash as Sha256;
use bitcoin::hashes::sha256d::Hash as Sha256d;
use bitcoin::hashes::Hash;

use bitcoin::secp256k1::constants::PUBLIC_KEY_SIZE;
use bitcoin::secp256k1::{ecdsa::Signature, Secp256k1};
use bitcoin::secp256k1::{PublicKey, SecretKey};
use bitcoin::{secp256k1, sighash, FeeRate, Sequence, TxIn};

use crate::blinded_path::message::BlindedMessagePath;
use crate::chain::chaininterface::{
	ChannelFunding, ConfirmationTarget, FeeEstimator, FundingCandidate, FundingPurpose,
	LowerBoundedFeeEstimator, TransactionType,
};
use crate::chain::channelmonitor::{
	ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, CommitmentHTLCData,
	LATENCY_GRACE_PERIOD_BLOCKS,
};
use crate::chain::package::verify_channel_type_features;
use crate::chain::transaction::{OutPoint, TransactionData};
use crate::chain::BlockLocator;
use crate::events::{
	ClosureReason, FailedSpliceContribution, FundingInfo, NegotiationFailureReason,
};
use crate::ln::chan_utils;
use crate::ln::chan_utils::{
	get_commitment_transaction_number_obscure_factor, max_htlcs, second_stage_tx_fees_sat,
	selected_commitment_sat_per_1000_weight, ChannelPublicKeys, ChannelTransactionParameters,
	ClosingTransaction, CommitmentTransaction, CounterpartyChannelTransactionParameters,
	CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HolderCommitmentTransaction,
	EMPTY_SCRIPT_SIG_WEIGHT, FUNDING_TRANSACTION_WITNESS_WEIGHT,
};
use crate::ln::channel_state::{
	ChannelShutdownState, ConfirmedSpliceCandidate, CounterpartyForwardingInfo, InboundHTLCDetails,
	InboundHTLCStateDetails, OutboundHTLCDetails, OutboundHTLCStateDetails, SpliceCandidateDetails,
	SpliceCandidateStatus, SpliceDetails,
};
use crate::ln::channelmanager::{
	self, BlindedFailure, ChannelReadyOrder, FundingConfirmedMessage, HTLCFailureMsg,
	HTLCPreviousHopData, HTLCSource, OpenChannelMessage, PaymentClaimDetails, PendingHTLCInfo,
	PendingHTLCStatus, RAACommitmentOrder, SentHTLCId, TrustedChannelFeatures, TxSignaturesOrder,
	BREAKDOWN_TIMEOUT, MAX_LOCAL_BREAKDOWN_TIMEOUT, MIN_CLTV_EXPIRY_DELTA,
};
use crate::ln::funding::{
	FeeRateAdjustmentError, FundingContribution, FundingTemplate, PendingFundingComponents,
};
use crate::ln::interactivetxs::{
	AbortReason, HandleTxCompleteValue, InteractiveTxConstructor, InteractiveTxConstructorArgs,
	InteractiveTxMessageSend, InteractiveTxSigningSession, SharedOwnedInput, SharedOwnedOutput,
};
use crate::ln::msgs;
use crate::ln::msgs::{ClosingSigned, ClosingSignedFeeRange, DecodeError, OnionErrorPacket};
use crate::ln::onion_utils::{
	AttributionData, HTLCFailReason, LocalHTLCFailureReason, HOLD_TIME_UNIT_MILLIS,
};
use crate::ln::script::{self, ShutdownScript};
use crate::ln::types::ChannelId;
use crate::offers::static_invoice::StaticInvoice;
use crate::routing::gossip::NodeId;
use crate::sign::ecdsa::EcdsaChannelSigner;
use crate::sign::tx_builder::{
	ChannelConstraints, ChannelStats, HTLCAmountDirection, SpecTxBuilder, TxBuilder,
};
use crate::sign::{ChannelSigner, EntropySource, NodeSigner, Recipient, SignerProvider};
use crate::types::features::{ChannelTypeFeatures, InitFeatures};
use crate::types::payment::{PaymentHash, PaymentPreimage};
use crate::util::config::{
	ChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits, LegacyChannelConfig,
	MaxDustHTLCExposure, UserConfig,
};
use crate::util::errors::APIError;
use crate::util::logger::{Logger, Record, WithContext};
use crate::util::scid_utils::{block_from_scid, scid_from_parts};
use crate::util::ser::{Iterable, Readable, ReadableArgs, RequiredWrapper, Writeable, Writer};
use crate::util::wallet_utils::{ConfirmedUtxo, Input};
use crate::{impl_readable_for_vec, impl_writeable_for_vec};

use alloc::collections::{btree_map, BTreeMap};

use crate::io;
use crate::prelude::*;
#[cfg(any(test, fuzzing, debug_assertions))]
use crate::sync::Mutex;
use core::time::Duration;
use core::{cmp, fmt, mem};

use super::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint};

#[cfg(any(test, feature = "_test_utils"))]
#[allow(unused)]
pub struct ChannelValueStat {
	pub value_to_self_msat: u64,
	pub channel_value_msat: u64,
	pub channel_reserve_msat: u64,
	pub pending_outbound_htlcs_amount_msat: u64,
	pub pending_inbound_htlcs_amount_msat: u64,
	pub holding_cell_outbound_amount_msat: u64,
	pub counterparty_max_htlc_value_in_flight_msat: u64, // outgoing
	pub counterparty_dust_limit_msat: u64,
}

pub struct AvailableBalances {
	/// Total amount available for our counterparty to send to us.
	pub inbound_capacity_msat: u64,
	/// Total amount available for us to send to our counterparty.
	pub outbound_capacity_msat: u64,
	/// The maximum value we can assign to the next outbound HTLC
	pub next_outbound_htlc_limit_msat: u64,
	/// The minimum value we can assign to the next outbound HTLC
	pub next_outbound_htlc_minimum_msat: u64,
	/// The current total dust exposure on this channel, in millisatoshis.
	///
	/// This is the maximum of the dust exposure on the holder and counterparty commitment
	/// transactions, and includes both the value of all pending HTLCs that are below the dust
	/// threshold as well as any excess commitment transaction fees that contribute to dust
	/// exposure.
	///
	/// See [`ChannelConfig::max_dust_htlc_exposure`] for more information on the dust calculation and to configure a limit.
	pub dust_exposure_msat: u64,
	/// The maximum value of the next splice-out
	pub next_splice_out_maximum_sat: u64,
}

#[derive(Debug, Clone, Copy, PartialEq)]
enum FeeUpdateState {
	// Inbound states mirroring InboundHTLCState
	RemoteAnnounced,
	AwaitingRemoteRevokeToAnnounce,
	// Note that we do not have a AwaitingAnnouncedRemoteRevoke variant here as it is universally
	// handled the same as `Committed`, with the only exception in `InboundHTLCState` being the
	// distinction of when we allow ourselves to forward the HTLC. Because we aren't "forwarding"
	// the fee update anywhere, we can simply consider the fee update `Committed` immediately
	// instead of setting it to AwaitingAnnouncedRemoteRevoke.

	// Outbound state can only be `LocalAnnounced` or `Committed`
	Outbound,
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum NextCommitmentView {
	ValidatingPeerUpdate,
	ValidatingOwnUpdate,
}

struct NextCommitmentProjection {
	next_value_to_self_msat: u64,
	next_commitment_htlcs: Vec<HTLCAmountDirection>,
}

#[derive(Debug)]
enum InboundHTLCRemovalReason {
	FailRelay(msgs::OnionErrorPacket),
	FailMalformed { sha256_of_onion: [u8; 32], failure_code: u16 },
	Fulfill { preimage: PaymentPreimage, attribution_data: Option<AttributionData> },
}

/// Represents the resolution status of an inbound HTLC.
#[cfg_attr(test, derive(Debug))]
#[derive(Clone)]
enum InboundHTLCResolution {
	/// Resolved implies the action we must take with the inbound HTLC has already been determined,
	/// i.e., we already know whether it must be failed back or forwarded.
	//
	// TODO: Once this variant is removed, we should also clean up
	// [`MonitorRestoreUpdates::accepted_htlcs`] as the path will be unreachable.
	Resolved { pending_htlc_status: PendingHTLCStatus },
	/// Pending implies we will attempt to resolve the inbound HTLC once it has been fully committed
	/// to by both sides of the channel, i.e., once a `revoke_and_ack` has been processed by both
	/// nodes for the state update in which it was proposed.
	Pending { update_add_htlc: msgs::UpdateAddHTLC },
}

impl_writeable_tlv_based_enum!(InboundHTLCResolution,
	(0, Resolved) => {
		(0, pending_htlc_status, required),
	},
	(2, Pending) => {
		(0, update_add_htlc, required),
	},
);

#[cfg_attr(test, derive(Debug))]
enum InboundHTLCState {
	/// Offered by remote, to be included in next local commitment tx. I.e., the remote sent an
	/// update_add_htlc message for this HTLC.
	RemoteAnnounced(InboundHTLCResolution),
	/// Included in a received commitment_signed message (implying we've
	/// revoke_and_ack'd it), but the remote hasn't yet revoked their previous
	/// state (see the example below). We have not yet included this HTLC in a
	/// commitment_signed message because we are waiting on the remote's
	/// aforementioned state revocation. One reason this missing remote RAA
	/// (revoke_and_ack) blocks us from constructing a commitment_signed message
	/// is because every time we create a new "state", i.e. every time we sign a
	/// new commitment tx (see [BOLT #2]), we need a new per_commitment_point,
	/// which are provided one-at-a-time in each RAA. E.g., the last RAA they
	/// sent provided the per_commitment_point for our current commitment tx.
	/// The other reason we should not send a commitment_signed without their RAA
	/// is because their RAA serves to ACK our previous commitment_signed.
	///
	/// Here's an example of how an HTLC could come to be in this state:
	/// remote --> update_add_htlc(prev_htlc)   --> local
	/// remote --> commitment_signed(prev_htlc) --> local
	/// remote <-- revoke_and_ack               <-- local
	/// remote <-- commitment_signed(prev_htlc) <-- local
	/// [note that here, the remote does not respond with a RAA]
	/// remote --> update_add_htlc(this_htlc)   --> local
	/// remote --> commitment_signed(prev_htlc, this_htlc) --> local
	/// Now `this_htlc` will be assigned this state. It's unable to be officially
	/// accepted, i.e. included in a commitment_signed, because we're missing the
	/// RAA that provides our next per_commitment_point. The per_commitment_point
	/// is used to derive commitment keys, which are used to construct the
	/// signatures in a commitment_signed message.
	/// Implies AwaitingRemoteRevoke.
	///
	/// [BOLT #2]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
	AwaitingRemoteRevokeToAnnounce(InboundHTLCResolution),
	/// Included in a received commitment_signed message (implying we've revoke_and_ack'd it).
	/// We have also included this HTLC in our latest commitment_signed and are now just waiting
	/// on the remote's revoke_and_ack to make this HTLC an irrevocable part of the state of the
	/// channel (before it can then get forwarded and/or removed).
	/// Implies AwaitingRemoteRevoke.
	AwaitingAnnouncedRemoteRevoke(InboundHTLCResolution),
	/// An HTLC irrevocably committed in the latest commitment transaction, ready to be forwarded or
	/// removed.
	Committed {
		/// Used to rebuild `ChannelManager` HTLC state on restart. Previously the manager would track
		/// and persist all HTLC forwards and receives itself, but newer LDK versions avoid relying on
		/// its persistence and instead reconstruct state based on `Channel` and `ChannelMonitor` data.
		update_add_htlc: InboundUpdateAdd,
	},
	/// Removed by us and a new commitment_signed was sent (if we were AwaitingRemoteRevoke when we
	/// created it we would have put it in the holding cell instead). When they next revoke_and_ack
	/// we'll drop it.
	/// Note that we have to keep an eye on the HTLC until we've received a broadcastable
	/// commitment transaction without it as otherwise we'll have to force-close the channel to
	/// claim it before the timeout (obviously doesn't apply to revoked HTLCs that we can't claim
	/// anyway). That said, ChannelMonitor does this for us (see
	/// ChannelMonitor::should_broadcast_holder_commitment_txn) so we actually remove the HTLC from
	/// our own local state before then, once we're sure that the next commitment_signed and
	/// ChannelMonitor::provide_latest_local_commitment_tx will not include this HTLC.
	LocalRemoved(InboundHTLCRemovalReason),
}

impl From<&InboundHTLCState> for Option<InboundHTLCStateDetails> {
	fn from(state: &InboundHTLCState) -> Option<InboundHTLCStateDetails> {
		match state {
			InboundHTLCState::RemoteAnnounced(_) => None,
			InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => {
				Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToAdd)
			},
			InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => {
				Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToAdd)
			},
			InboundHTLCState::Committed { .. } => Some(InboundHTLCStateDetails::Committed),
			InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(_)) => {
				Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail)
			},
			InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed { .. }) => {
				Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail)
			},
			InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill { .. }) => {
				Some(InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFulfill)
			},
		}
	}
}

impl fmt::Display for InboundHTLCState {
	#[rustfmt::skip]
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			InboundHTLCState::RemoteAnnounced(_) => write!(f, "RemoteAnnounced"),
			InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => write!(f, "AwaitingRemoteRevokeToAnnounce"),
			InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => write!(f, "AwaitingAnnouncedRemoteRevoke"),
			InboundHTLCState::Committed { .. } => write!(f, "Committed"),
			InboundHTLCState::LocalRemoved(_) => write!(f, "LocalRemoved"),
		}
	}
}

impl InboundHTLCState {
	fn included_in_commitment(&self, generated_by_local: bool) -> bool {
		match self {
			InboundHTLCState::RemoteAnnounced(_) => !generated_by_local,
			InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => !generated_by_local,
			InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => true,
			InboundHTLCState::Committed { .. } => true,
			InboundHTLCState::LocalRemoved(_) => !generated_by_local,
		}
	}

	fn preimage(&self) -> Option<PaymentPreimage> {
		match self {
			InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill {
				preimage, ..
			}) => Some(*preimage),
			_ => None,
		}
	}

	/// Whether we need to hold onto this HTLC until receipt of a corresponding [`ReleaseHeldHtlc`]
	/// onion message.
	///
	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
	fn should_hold_htlc(&self) -> bool {
		match self {
			InboundHTLCState::RemoteAnnounced(res)
			| InboundHTLCState::AwaitingRemoteRevokeToAnnounce(res)
			| InboundHTLCState::AwaitingAnnouncedRemoteRevoke(res) => match res {
				InboundHTLCResolution::Pending { update_add_htlc } => {
					update_add_htlc.hold_htlc.is_some()
				},
				InboundHTLCResolution::Resolved { .. } => false,
			},
			InboundHTLCState::Committed { .. } | InboundHTLCState::LocalRemoved(_) => false,
		}
	}
}

/// Information about the outbound hop for a forwarded HTLC. Useful for generating an accurate
/// [`Event::PaymentForwarded`] if we need to claim this HTLC post-restart.
///
/// [`Event::PaymentForwarded`]: crate::events::Event::PaymentForwarded
#[derive(Debug, Copy, Clone)]
pub(super) struct OutboundHop {
	/// The amount forwarded outbound.
	pub(super) amt_msat: u64,
	/// The outbound channel this HTLC was forwarded over.
	pub(super) channel_id: ChannelId,
	/// The next-hop recipient of this HTLC.
	pub(super) node_id: PublicKey,
	/// The outbound channel's funding outpoint.
	pub(super) funding_txo: OutPoint,
	/// The outbound channel's user channel ID.
	pub(super) user_channel_id: u128,
}

impl_writeable_tlv_based!(OutboundHop, {
	(0, amt_msat, required),
	(2, channel_id, required),
	(4, node_id, required),
	(6, funding_txo, required),
	(8, user_channel_id, required),
});

/// A field of `InboundHTLCState::Committed` containing the HTLC's `update_add_htlc` message. If
/// the HTLC is a forward and gets irrevocably committed to the outbound edge, we convert to
/// `InboundUpdateAdd::Forwarded`, thus pruning the onion and not persisting it on every
/// `ChannelManager` persist.
///
/// Useful for reconstructing the pending HTLC set on startup.
#[derive(Debug, Clone)]
enum InboundUpdateAdd {
	/// The inbound committed HTLC's update_add_htlc message.
	WithOnion { update_add_htlc: msgs::UpdateAddHTLC },
	/// This inbound HTLC is a forward that was irrevocably committed to the outbound edge, allowing
	/// its onion to be pruned and no longer persisted.
	///
	/// Contains data that is useful if we need to fail or claim this HTLC backwards after a restart
	/// and it's missing in the outbound edge.
	Forwarded {
		incoming_packet_shared_secret: [u8; 32],
		phantom_shared_secret: Option<[u8; 32]>,
		trampoline_shared_secret: Option<[u8; 32]>,
		blinded_failure: Option<BlindedFailure>,
		outbound_hop: OutboundHop,
	},
	/// This HTLC was received before we started persisting the onion for inbound committed HTLCs.
	Legacy,
}

impl_writeable_tlv_based_enum_upgradable!(InboundUpdateAdd,
	(0, WithOnion) => {
		(0, update_add_htlc, required),
	},
	(2, Legacy) => {},
	(4, Forwarded) => {
		(0, incoming_packet_shared_secret, required),
		(2, outbound_hop, required),
		(4, phantom_shared_secret, option),
		(6, trampoline_shared_secret, option),
		(8, blinded_failure, option),
	},
);

impl_writeable_for_vec!(&InboundUpdateAdd);
impl_readable_for_vec!(InboundUpdateAdd);

#[cfg_attr(test, derive(Debug))]
struct InboundHTLCOutput {
	htlc_id: u64,
	amount_msat: u64,
	cltv_expiry: u32,
	payment_hash: PaymentHash,
	state: InboundHTLCState,
}

#[derive(Debug)]
#[cfg_attr(test, derive(Clone, PartialEq))]
enum OutboundHTLCState {
	/// Added by us and included in a commitment_signed (if we were AwaitingRemoteRevoke when we
	/// created it we would have put it in the holding cell instead). When they next revoke_and_ack
	/// we will promote to Committed (note that they may not accept it until the next time we
	/// revoke, but we don't really care about that:
	///  * they've revoked, so worst case we can announce an old state and get our (option on)
	///    money back (though we won't), and,
	///  * we'll send them a revoke when they send a commitment_signed, and since only they're
	///    allowed to remove it, the "can only be removed once committed on both sides" requirement
	///    doesn't matter to us and it's up to them to enforce it, worst-case they jump ahead but
	///    we'll never get out of sync).
	/// Note that we Box the OnionPacket as it's rather large and we don't want to blow up
	/// OutboundHTLCOutput's size just for a temporary bit
	LocalAnnounced(Box<msgs::OnionPacket>),
	Committed,
	/// Remote removed this (outbound) HTLC. We're waiting on their commitment_signed to finalize
	/// the change (though they'll need to revoke before we fail the payment).
	RemoteRemoved(OutboundHTLCOutcome),
	/// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
	/// the remote side hasn't yet revoked their previous state, which we need them to do before we
	/// can do any backwards failing. Implies AwaitingRemoteRevoke.
	/// We also have not yet removed this HTLC in a commitment_signed message, and are waiting on a
	/// remote revoke_and_ack on a previous state before we can do so.
	AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome),
	/// Remote removed this and sent a commitment_signed (implying we've revoke_and_ack'ed it), but
	/// the remote side hasn't yet revoked their previous state, which we need them to do before we
	/// can do any backwards failing. Implies AwaitingRemoteRevoke.
	/// We have removed this HTLC in our latest commitment_signed and are now just waiting on a
	/// revoke_and_ack to drop completely.
	AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome),
}

impl From<&OutboundHTLCState> for OutboundHTLCStateDetails {
	fn from(state: &OutboundHTLCState) -> OutboundHTLCStateDetails {
		match state {
			OutboundHTLCState::LocalAnnounced(_) => {
				OutboundHTLCStateDetails::AwaitingRemoteRevokeToAdd
			},
			OutboundHTLCState::Committed => OutboundHTLCStateDetails::Committed,
			// RemoteRemoved states are ignored as the state is transient and the remote has not committed to
			// the state yet.
			OutboundHTLCState::RemoteRemoved(_) => OutboundHTLCStateDetails::Committed,
			OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success {
				..
			}) => OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveSuccess,
			OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Failure(_)) => {
				OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFailure
			},
			OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success {
				..
			}) => OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveSuccess,
			OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Failure(_)) => {
				OutboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFailure
			},
		}
	}
}

impl fmt::Display for OutboundHTLCState {
	#[rustfmt::skip]
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			OutboundHTLCState::LocalAnnounced(_) => write!(f, "LocalAnnounced"),
			OutboundHTLCState::Committed => write!(f, "Committed"),
			OutboundHTLCState::RemoteRemoved(_) => write!(f, "RemoteRemoved"),
			OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) => write!(f, "AwaitingRemoteRevokeToRemove"),
			OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => write!(f, "AwaitingRemovedRemoteRevoke"),
		}
	}
}

impl OutboundHTLCState {
	fn included_in_commitment(&self, generated_by_local: bool) -> bool {
		match self {
			OutboundHTLCState::LocalAnnounced(_) => generated_by_local,
			OutboundHTLCState::Committed => true,
			OutboundHTLCState::RemoteRemoved(_) => generated_by_local,
			OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) => generated_by_local,
			OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => false,
		}
	}

	fn preimage(&self) -> Option<PaymentPreimage> {
		match self {
			OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success { preimage, .. })
			| OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success {
				preimage,
				..
			})
			| OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success {
				preimage,
				..
			}) => Some(*preimage),
			_ => None,
		}
	}
}

#[derive(Clone, Debug)]
#[cfg_attr(test, derive(PartialEq))]
enum OutboundHTLCOutcome {
	/// We started always filling in the preimages here in 0.0.105, and the requirement
	/// that the preimages always be filled in was added in 0.2.
	Success {
		preimage: PaymentPreimage,
		attribution_data: Option<AttributionData>,
	},
	Failure(HTLCFailReason),
}

impl<'a> Into<Option<&'a HTLCFailReason>> for &'a OutboundHTLCOutcome {
	fn into(self) -> Option<&'a HTLCFailReason> {
		match self {
			OutboundHTLCOutcome::Success { .. } => None,
			OutboundHTLCOutcome::Failure(ref r) => Some(r),
		}
	}
}

#[derive(Debug)]
#[cfg_attr(test, derive(Clone, PartialEq))]
struct OutboundHTLCOutput {
	htlc_id: u64,
	amount_msat: u64,
	cltv_expiry: u32,
	payment_hash: PaymentHash,
	state: OutboundHTLCState,
	source: HTLCSource,
	blinding_point: Option<PublicKey>,
	skimmed_fee_msat: Option<u64>,
	send_timestamp: Option<Duration>,
	hold_htlc: Option<()>,
	accountable: bool,
}

/// See AwaitingRemoteRevoke ChannelState for more info
#[derive(Debug)]
#[cfg_attr(test, derive(Clone, PartialEq))]
enum HTLCUpdateAwaitingACK {
	AddHTLC {
		// TODO: Time out if we're getting close to cltv_expiry
		// always outbound
		amount_msat: u64,
		cltv_expiry: u32,
		payment_hash: PaymentHash,
		source: HTLCSource,
		onion_routing_packet: msgs::OnionPacket,
		// The extra fee we're skimming off the top of this HTLC.
		skimmed_fee_msat: Option<u64>,
		blinding_point: Option<PublicKey>,
		hold_htlc: Option<()>,
		accountable: bool,
	},
	ClaimHTLC {
		payment_preimage: PaymentPreimage,
		attribution_data: Option<AttributionData>,
		htlc_id: u64,
	},
	FailHTLC {
		htlc_id: u64,
		err_packet: msgs::OnionErrorPacket,
	},
	FailMalformedHTLC {
		htlc_id: u64,
		failure_code: u16,
		sha256_of_onion: [u8; 32],
	},
}

macro_rules! define_state_flags {
	($flag_type_doc: expr, $flag_type: ident, [$(($flag_doc: expr, $flag: ident, $value: expr, $get: ident, $set: ident, $clear: ident)),*], $extra_flags: expr) => {
		#[doc = $flag_type_doc]
		#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq)]
		struct $flag_type(u32);

		impl $flag_type {
			$(
				#[doc = $flag_doc]
				const $flag: $flag_type = $flag_type($value);
			)*

			/// All flags that apply to the specified [`ChannelState`] variant.
			#[allow(unused)]
			const ALL: $flag_type = Self($(Self::$flag.0 | )* $extra_flags);

			#[allow(unused)]
			fn new() -> Self { Self(0) }

			#[allow(unused)]
			fn from_u32(flags: u32) -> Result<Self, ()> {
				if flags & !Self::ALL.0 != 0 {
					Err(())
				} else {
					Ok($flag_type(flags))
				}
			}

			#[allow(unused)]
			fn is_empty(&self) -> bool { self.0 == 0 }
			#[allow(unused)]
			fn is_set(&self, flag: Self) -> bool { *self & flag == flag }
			#[allow(unused)]
			fn set(&mut self, flag: Self) { *self |= flag }
			#[allow(unused)]
			fn clear(&mut self, flag: Self) -> Self { self.0 &= !flag.0; *self }
		}

		$(
			define_state_flags!($flag_type, Self::$flag, $get, $set, $clear);
		)*

		impl core::ops::BitOr for $flag_type {
			type Output = Self;
			fn bitor(self, rhs: Self) -> Self::Output { Self(self.0 | rhs.0) }
		}
		impl core::ops::BitOrAssign for $flag_type {
			fn bitor_assign(&mut self, rhs: Self) { self.0 |= rhs.0; }
		}
		impl core::ops::BitAnd for $flag_type {
			type Output = Self;
			fn bitand(self, rhs: Self) -> Self::Output { Self(self.0 & rhs.0) }
		}
		impl core::ops::BitAndAssign for $flag_type {
			fn bitand_assign(&mut self, rhs: Self) { self.0 &= rhs.0; }
		}
	};
	($flag_type_doc: expr, $flag_type: ident, $flags: tt) => {
		define_state_flags!($flag_type_doc, $flag_type, $flags, 0);
	};
	($flag_type: ident, $flag: expr, $get: ident, $set: ident, $clear: ident) => {
		impl $flag_type {
			#[allow(unused)]
			fn $get(&self) -> bool { self.is_set($flag_type::new() | $flag) }
			#[allow(unused)]
			fn $set(&mut self) { self.set($flag_type::new() | $flag) }
			#[allow(unused)]
			fn $clear(&mut self) -> Self { self.clear($flag_type::new() | $flag) }
		}
	};
	($flag_type_doc: expr, FUNDED_STATE, $flag_type: ident, $flags: tt) => {
		define_state_flags!($flag_type_doc, $flag_type, $flags, FundedStateFlags::ALL.0);

		define_state_flags!($flag_type, FundedStateFlags::PEER_DISCONNECTED,
			is_peer_disconnected, set_peer_disconnected, clear_peer_disconnected);
		define_state_flags!($flag_type, FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS,
			is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress);
		define_state_flags!($flag_type, FundedStateFlags::REMOTE_SHUTDOWN_SENT,
			is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent);
		define_state_flags!($flag_type, FundedStateFlags::LOCAL_SHUTDOWN_SENT,
			is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent);

		impl core::ops::BitOr<FundedStateFlags> for $flag_type {
			type Output = Self;
			fn bitor(self, rhs: FundedStateFlags) -> Self::Output { Self(self.0 | rhs.0) }
		}
		impl core::ops::BitOrAssign<FundedStateFlags> for $flag_type {
			fn bitor_assign(&mut self, rhs: FundedStateFlags) { self.0 |= rhs.0; }
		}
		impl core::ops::BitAnd<FundedStateFlags> for $flag_type {
			type Output = Self;
			fn bitand(self, rhs: FundedStateFlags) -> Self::Output { Self(self.0 & rhs.0) }
		}
		impl core::ops::BitAndAssign<FundedStateFlags> for $flag_type {
			fn bitand_assign(&mut self, rhs: FundedStateFlags) { self.0 &= rhs.0; }
		}
		impl PartialEq<FundedStateFlags> for $flag_type {
			fn eq(&self, other: &FundedStateFlags) -> bool { self.0 == other.0 }
		}
		impl From<FundedStateFlags> for $flag_type {
			fn from(flags: FundedStateFlags) -> Self { Self(flags.0) }
		}
	};
}

/// We declare all the states/flags here together to help determine which bits are still available
/// to choose.
mod state_flags {
	pub const OUR_INIT_SENT: u32 = 1 << 0;
	pub const THEIR_INIT_SENT: u32 = 1 << 1;
	pub const FUNDING_NEGOTIATED: u32 = 1 << 2;
	pub const AWAITING_CHANNEL_READY: u32 = 1 << 3;
	pub const THEIR_CHANNEL_READY: u32 = 1 << 4;
	pub const OUR_CHANNEL_READY: u32 = 1 << 5;
	pub const CHANNEL_READY: u32 = 1 << 6;
	pub const PEER_DISCONNECTED: u32 = 1 << 7;
	pub const MONITOR_UPDATE_IN_PROGRESS: u32 = 1 << 8;
	pub const AWAITING_REMOTE_REVOKE: u32 = 1 << 9;
	pub const REMOTE_SHUTDOWN_SENT: u32 = 1 << 10;
	pub const LOCAL_SHUTDOWN_SENT: u32 = 1 << 11;
	pub const SHUTDOWN_COMPLETE: u32 = 1 << 12;
	pub const WAITING_FOR_BATCH: u32 = 1 << 13;
	pub const LOCAL_STFU_SENT: u32 = 1 << 14;
	pub const REMOTE_STFU_SENT: u32 = 1 << 15;
	pub const QUIESCENT: u32 = 1 << 16;
}

define_state_flags!(
	"Flags that apply to all [`ChannelState`] variants in which the channel is funded.",
	FundedStateFlags, [
		("Indicates the remote side is considered \"disconnected\" and no updates are allowed \
			until after we've done a `channel_reestablish` dance.", PEER_DISCONNECTED, state_flags::PEER_DISCONNECTED,
			is_peer_disconnected, set_peer_disconnected, clear_peer_disconnected),
		("Indicates the user has told us a `ChannelMonitor` update is pending async persistence \
			somewhere and we should pause sending any outbound messages until they've managed to \
			complete it.", MONITOR_UPDATE_IN_PROGRESS, state_flags::MONITOR_UPDATE_IN_PROGRESS,
			is_monitor_update_in_progress, set_monitor_update_in_progress, clear_monitor_update_in_progress),
		("Indicates we received a `shutdown` message from the remote end. If set, they may not add \
			any new HTLCs to the channel, and we are expected to respond with our own `shutdown` \
			message when possible.", REMOTE_SHUTDOWN_SENT, state_flags::REMOTE_SHUTDOWN_SENT,
			is_remote_shutdown_sent, set_remote_shutdown_sent, clear_remote_shutdown_sent),
		("Indicates we sent a `shutdown` message. At this point, we may not add any new HTLCs to \
			the channel.", LOCAL_SHUTDOWN_SENT, state_flags::LOCAL_SHUTDOWN_SENT,
			is_local_shutdown_sent, set_local_shutdown_sent, clear_local_shutdown_sent)
	]
);

define_state_flags!(
	"Flags that only apply to [`ChannelState::NegotiatingFunding`].",
	NegotiatingFundingFlags, [
		("Indicates we have (or are prepared to) send our `open_channel`/`accept_channel` message.",
			OUR_INIT_SENT, state_flags::OUR_INIT_SENT, is_our_init_sent, set_our_init_sent, clear_our_init_sent),
		("Indicates we have received their `open_channel`/`accept_channel` message.",
			THEIR_INIT_SENT, state_flags::THEIR_INIT_SENT, is_their_init_sent, set_their_init_sent, clear_their_init_sent)
	]
);

define_state_flags!(
	"Flags that only apply to [`ChannelState::FundingNegotiated`].",
	FUNDED_STATE,
	FundingNegotiatedFlags,
	[]
);

define_state_flags!(
	"Flags that only apply to [`ChannelState::AwaitingChannelReady`].",
	FUNDED_STATE, AwaitingChannelReadyFlags, [
		("Indicates they sent us a `channel_ready` message. Once both `THEIR_CHANNEL_READY` and \
			`OUR_CHANNEL_READY` are set, our state moves on to `ChannelReady`.",
			THEIR_CHANNEL_READY, state_flags::THEIR_CHANNEL_READY,
			is_their_channel_ready, set_their_channel_ready, clear_their_channel_ready),
		("Indicates we sent them a `channel_ready` message. Once both `THEIR_CHANNEL_READY` and \
			`OUR_CHANNEL_READY` are set, our state moves on to `ChannelReady`.",
			OUR_CHANNEL_READY, state_flags::OUR_CHANNEL_READY,
			is_our_channel_ready, set_our_channel_ready, clear_our_channel_ready),
		("Indicates the channel was funded in a batch and the broadcast of the funding transaction \
			is being held until all channels in the batch have received `funding_signed` and have \
			their monitors persisted.", WAITING_FOR_BATCH, state_flags::WAITING_FOR_BATCH,
			is_waiting_for_batch, set_waiting_for_batch, clear_waiting_for_batch)
	]
);

define_state_flags!(
	"Flags that only apply to [`ChannelState::ChannelReady`].",
	FUNDED_STATE, ChannelReadyFlags, [
		("Indicates that we have sent a `commitment_signed` but are awaiting the responding \
			`revoke_and_ack` message. During this period, we can't generate new `commitment_signed` \
			messages as we'd be unable to determine which HTLCs they included in their `revoke_and_ack` \
			implicit ACK, so instead we have to hold them away temporarily to be sent later.",
			AWAITING_REMOTE_REVOKE, state_flags::AWAITING_REMOTE_REVOKE,
			is_awaiting_remote_revoke, set_awaiting_remote_revoke, clear_awaiting_remote_revoke),
		("Indicates we have sent a `stfu` message to the counterparty. This message can only be sent \
			if `REMOTE_STFU_SENT` is set, or a `QuiescentAction` is pending. Shutdown requests are \
			rejected if this flag is set.",
			LOCAL_STFU_SENT, state_flags::LOCAL_STFU_SENT,
			is_local_stfu_sent, set_local_stfu_sent, clear_local_stfu_sent),
		("Indicates we have received a `stfu` message from the counterparty. Shutdown requests are \
			rejected if this flag is set.",
			REMOTE_STFU_SENT, state_flags::REMOTE_STFU_SENT,
			is_remote_stfu_sent, set_remote_stfu_sent, clear_remote_stfu_sent),
		("Indicates the quiescence handshake has completed and the channel is now quiescent. \
			Updates are not allowed while this flag is set, and any outbound updates will go \
			directly into the holding cell.",
			QUIESCENT, state_flags::QUIESCENT,
			is_quiescent, set_quiescent, clear_quiescent)
	]
);

// Note that the order of this enum is implicitly defined by where each variant is placed. Take this
// into account when introducing new states and update `test_channel_state_order` accordingly.
#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq)]
enum ChannelState {
	/// We are negotiating the parameters required for the channel prior to funding it.
	NegotiatingFunding(NegotiatingFundingFlags),
	/// We have sent `funding_created` and are awaiting a `funding_signed` to advance to
	/// `AwaitingChannelReady`. Note that this is nonsense for an inbound channel as we immediately generate
	/// `funding_signed` upon receipt of `funding_created`, so simply skip this state.
	///
	/// For inbound and outbound interactively funded channels (dual-funding), this state indicates
	/// that interactive transaction construction has been completed and we are now interactively
	/// signing the initial funding transaction.
	FundingNegotiated(FundingNegotiatedFlags),
	/// We've received/sent `funding_created` and `funding_signed` and are thus now waiting on the
	/// funding transaction to confirm.
	AwaitingChannelReady(AwaitingChannelReadyFlags),
	/// Both we and our counterparty consider the funding transaction confirmed and the channel is
	/// now operational.
	ChannelReady(ChannelReadyFlags),
	/// We've successfully negotiated a `closing_signed` dance. At this point, the `ChannelManager`
	/// is about to drop us, but we store this anyway.
	ShutdownComplete,
}

macro_rules! impl_state_flag {
	($get: ident, $set: ident, $clear: ident, [$($state: ident),+]) => {
		#[allow(unused)]
		fn $get(&self) -> bool {
			match self {
				$(
					ChannelState::$state(flags) => flags.$get(),
				)*
				_ => false,
			}
		}
		#[allow(unused)]
		fn $set(&mut self) {
			match self {
				$(
					ChannelState::$state(flags) => flags.$set(),
				)*
				_ => debug_assert!(false, "Attempted to set flag on unexpected ChannelState"),
			}
		}
		#[allow(unused)]
		fn $clear(&mut self) {
			match self {
				$(
					ChannelState::$state(flags) => { let _ = flags.$clear(); },
				)*
				_ => debug_assert!(false, "Attempted to clear flag on unexpected ChannelState"),
			}
		}
	};
	($get: ident, $set: ident, $clear: ident, FUNDED_STATES) => {
		impl_state_flag!($get, $set, $clear, [FundingNegotiated, AwaitingChannelReady, ChannelReady]);
	};
	($get: ident, $set: ident, $clear: ident, $state: ident) => {
		impl_state_flag!($get, $set, $clear, [$state]);
	};
}

impl ChannelState {
	#[rustfmt::skip]
	fn from_u32(state: u32) -> Result<Self, ()> {
		match state {
			state_flags::SHUTDOWN_COMPLETE => Ok(ChannelState::ShutdownComplete),
			val => {
				if val & state_flags::FUNDING_NEGOTIATED == state_flags::FUNDING_NEGOTIATED {
					FundingNegotiatedFlags::from_u32(val & !state_flags::FUNDING_NEGOTIATED)
						.map(|flags| ChannelState::FundingNegotiated(flags))
				} else if val & state_flags::AWAITING_CHANNEL_READY == state_flags::AWAITING_CHANNEL_READY {
					AwaitingChannelReadyFlags::from_u32(val & !state_flags::AWAITING_CHANNEL_READY)
						.map(|flags| ChannelState::AwaitingChannelReady(flags))
				} else if val & state_flags::CHANNEL_READY == state_flags::CHANNEL_READY {
					ChannelReadyFlags::from_u32(val & !state_flags::CHANNEL_READY)
						.map(|flags| ChannelState::ChannelReady(flags))
				} else if let Ok(flags) = NegotiatingFundingFlags::from_u32(val) {
					Ok(ChannelState::NegotiatingFunding(flags))
				} else {
					Err(())
				}
			},
		}
	}

	fn to_u32(self) -> u32 {
		match self {
			ChannelState::NegotiatingFunding(flags) => flags.0,
			ChannelState::FundingNegotiated(flags) => state_flags::FUNDING_NEGOTIATED | flags.0,
			ChannelState::AwaitingChannelReady(flags) => {
				state_flags::AWAITING_CHANNEL_READY | flags.0
			},
			ChannelState::ChannelReady(flags) => state_flags::CHANNEL_READY | flags.0,
			ChannelState::ShutdownComplete => state_flags::SHUTDOWN_COMPLETE,
		}
	}

	fn is_both_sides_shutdown(&self) -> bool {
		self.is_local_shutdown_sent() && self.is_remote_shutdown_sent()
	}

	fn with_funded_state_flags_mask(&self) -> FundedStateFlags {
		match self {
			ChannelState::AwaitingChannelReady(flags) => {
				FundedStateFlags((*flags & FundedStateFlags::ALL).0)
			},
			ChannelState::ChannelReady(flags) => {
				FundedStateFlags((*flags & FundedStateFlags::ALL).0)
			},
			_ => FundedStateFlags::new(),
		}
	}

	#[rustfmt::skip]
	fn can_generate_new_commitment(&self) -> bool {
		match self {
			ChannelState::ChannelReady(flags) =>
				!flags.is_set(ChannelReadyFlags::AWAITING_REMOTE_REVOKE) &&
					!flags.is_set(ChannelReadyFlags::LOCAL_STFU_SENT) &&
					!flags.is_set(ChannelReadyFlags::QUIESCENT) &&
					!flags.is_set(FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS.into()) &&
					!flags.is_set(FundedStateFlags::PEER_DISCONNECTED.into()),
			_ => {
				debug_assert!(false, "Can only generate new commitment within ChannelReady");
				false
			},
		}
	}

	impl_state_flag!(
		is_peer_disconnected,
		set_peer_disconnected,
		clear_peer_disconnected,
		FUNDED_STATES
	);
	impl_state_flag!(
		is_monitor_update_in_progress,
		set_monitor_update_in_progress,
		clear_monitor_update_in_progress,
		FUNDED_STATES
	);
	impl_state_flag!(
		is_local_shutdown_sent,
		set_local_shutdown_sent,
		clear_local_shutdown_sent,
		FUNDED_STATES
	);
	impl_state_flag!(
		is_remote_shutdown_sent,
		set_remote_shutdown_sent,
		clear_remote_shutdown_sent,
		FUNDED_STATES
	);
	impl_state_flag!(
		is_our_channel_ready,
		set_our_channel_ready,
		clear_our_channel_ready,
		AwaitingChannelReady
	);
	impl_state_flag!(
		is_their_channel_ready,
		set_their_channel_ready,
		clear_their_channel_ready,
		AwaitingChannelReady
	);
	impl_state_flag!(
		is_waiting_for_batch,
		set_waiting_for_batch,
		clear_waiting_for_batch,
		AwaitingChannelReady
	);
	impl_state_flag!(
		is_awaiting_remote_revoke,
		set_awaiting_remote_revoke,
		clear_awaiting_remote_revoke,
		ChannelReady
	);
	impl_state_flag!(is_local_stfu_sent, set_local_stfu_sent, clear_local_stfu_sent, ChannelReady);
	impl_state_flag!(
		is_remote_stfu_sent,
		set_remote_stfu_sent,
		clear_remote_stfu_sent,
		ChannelReady
	);
	impl_state_flag!(is_quiescent, set_quiescent, clear_quiescent, ChannelReady);
}

pub const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;

pub const DEFAULT_MAX_HTLCS: u16 = 50;

pub const ANCHOR_OUTPUT_VALUE_SATOSHI: u64 = 330;

/// The percentage of the channel value `holder_max_htlc_value_in_flight_msat` used to be set to,
/// before this was made configurable. The percentage was made configurable in LDK 0.0.107,
/// although LDK 0.0.104+ enabled serialization of channels with a different value set for
/// `holder_max_htlc_value_in_flight_msat`.
pub const MAX_IN_FLIGHT_PERCENT_LEGACY: u8 = 10;

/// Maximum `funding_satoshis` value according to the BOLT #2 specification, if
/// `option_support_large_channel` (aka wumbo channels) is not supported.
/// It's 2^24 - 1.
pub const MAX_FUNDING_SATOSHIS_NO_WUMBO: u64 = (1 << 24) - 1;

/// Total bitcoin supply in satoshis.
pub const TOTAL_BITCOIN_SUPPLY_SATOSHIS: u64 = 21_000_000 * 1_0000_0000;

/// The maximum network dust limit for standard script formats. This currently represents the
/// minimum output value for a P2SH output before Bitcoin Core 22 considers the entire
/// transaction non-standard and thus refuses to relay it.
/// We also use this as the maximum counterparty `dust_limit_satoshis` allowed, given many
/// implementations use this value for their dust limit today.
pub const MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS: u64 = 546;

/// The maximum channel dust limit we will accept from our counterparty for non-anchor channels.
pub const MAX_LEGACY_CHAN_DUST_LIMIT_SATOSHIS: u64 = MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS;

/// The maximum channel dust limit we will accept from our counterparty.
pub const MAX_CHAN_DUST_LIMIT_SATOSHIS: u64 = 10_000;

/// The dust limit is used for both the commitment transaction outputs as well as the closing
/// transactions. For cooperative closing transactions, we require segwit outputs, though accept
/// *any* segwit scripts, which are allowed to be up to 42 bytes in length.
/// In order to avoid having to concern ourselves with standardness during the closing process, we
/// simply require our counterparty to use a dust limit which will leave any segwit output
/// standard.
/// See <https://github.com/lightning/bolts/issues/905> for more details.
pub const MIN_CHAN_DUST_LIMIT_SATOSHIS: u64 = 354;

// Just a reasonable implementation-specific safe lower bound, higher than the dust limit.
pub const MIN_THEIR_CHAN_RESERVE_SATOSHIS: u64 = 1000;

// Just a reasonable implementation-specific safe lower bound.
pub const MIN_CHANNEL_VALUE_SATOSHIS: u64 = 1000;

/// Used to return a simple Error back to ChannelManager. Will get converted to a
/// msgs::ErrorAction::SendErrorMessage or msgs::ErrorAction::IgnoreError as appropriate with our
/// channel_id in ChannelManager.
pub(super) enum ChannelError {
	Ignore(String),
	Warn(String),
	WarnAndDisconnect(String),
	Abort(AbortReason),
	Close((String, ClosureReason)),
	SendError(String),
}

impl fmt::Debug for ChannelError {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			&ChannelError::Ignore(ref e) => write!(f, "Ignore: {}", e),
			&ChannelError::Warn(ref e) => write!(f, "Warn: {}", e),
			&ChannelError::WarnAndDisconnect(ref e) => {
				write!(f, "Disconnecting with warning: {}", e)
			},
			&ChannelError::Abort(ref reason) => write!(f, "Abort: {}", reason),
			&ChannelError::Close((ref e, _)) => write!(f, "Close: {}", e),
			&ChannelError::SendError(ref e) => write!(f, "Not Found: {}", e),
		}
	}
}

impl fmt::Display for ChannelError {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			&ChannelError::Ignore(ref e) => write!(f, "{}", e),
			&ChannelError::Warn(ref e) => write!(f, "{}", e),
			&ChannelError::WarnAndDisconnect(ref e) => write!(f, "{}", e),
			&ChannelError::Abort(ref reason) => write!(f, "{}", reason),
			&ChannelError::Close((ref e, _)) => write!(f, "{}", e),
			&ChannelError::SendError(ref e) => write!(f, "{}", e),
		}
	}
}

impl ChannelError {
	pub(super) fn close(err: String) -> Self {
		ChannelError::Close((err.clone(), ClosureReason::ProcessingError { err }))
	}
}

pub(super) struct WithChannelContext<'a, L: Logger> {
	pub logger: &'a L,
	pub peer_id: Option<PublicKey>,
	pub channel_id: Option<ChannelId>,
	pub payment_hash: Option<PaymentHash>,
}

impl<'a, L: Logger> Logger for WithChannelContext<'a, L> {
	fn log(&self, mut record: Record) {
		record.peer_id = self.peer_id;
		record.channel_id = self.channel_id;
		record.payment_hash = self.payment_hash;
		self.logger.log(record)
	}
}

impl<'a, 'b, L: Logger> WithChannelContext<'a, L> {
	pub(super) fn from<S: SignerProvider>(
		logger: &'a L, context: &'b ChannelContext<S>, payment_hash: Option<PaymentHash>,
	) -> Self {
		WithChannelContext {
			logger,
			peer_id: Some(context.counterparty_node_id),
			channel_id: Some(context.channel_id),
			payment_hash,
		}
	}
}

macro_rules! secp_check {
	($res: expr, $err: expr) => {
		match $res {
			Ok(thing) => thing,
			Err(_) => return Err(ChannelError::close($err)),
		}
	};
}

/// The "channel disabled" bit in channel_update must be set based on whether we are connected to
/// our counterparty or not. However, we don't want to announce updates right away to avoid
/// spamming the network with updates if the connection is flapping. Instead, we "stage" updates to
/// our channel_update message and track the current state here.
/// See implementation at [`super::channelmanager::ChannelManager::timer_tick_occurred`].
#[derive(Clone, Copy, PartialEq, Debug)]
pub(super) enum ChannelUpdateStatus {
	/// We've announced the channel as enabled and are connected to our peer.
	Enabled,
	/// Our channel is no longer live, but we haven't announced the channel as disabled yet.
	DisabledStaged(u8),
	/// Our channel is live again, but we haven't announced the channel as enabled yet.
	EnabledStaged(u8),
	/// We've announced the channel as disabled.
	Disabled,
}

/// We track when we sent an `AnnouncementSignatures` to our peer in a few states, described here.
#[cfg_attr(test, derive(Debug))]
#[derive(PartialEq)]
pub enum AnnouncementSigsState {
	/// We have not sent our peer an `AnnouncementSignatures` yet, or our peer disconnected since
	/// we sent the last `AnnouncementSignatures`.
	NotSent,
	/// We sent an `AnnouncementSignatures` to our peer since the last time our peer disconnected.
	/// This state never appears on disk - instead we write `NotSent`.
	MessageSent,
	/// We sent a `CommitmentSigned` after the last `AnnouncementSignatures` we sent. Because we
	/// only ever have a single `CommitmentSigned` pending at once, if we sent one after sending
	/// `AnnouncementSignatures` then we know the peer received our `AnnouncementSignatures` if
	/// they send back a `RevokeAndACK`.
	/// This state never appears on disk - instead we write `NotSent`.
	Committed,
	/// We received a `RevokeAndACK`, effectively ack-ing our `AnnouncementSignatures`, at this
	/// point we no longer need to re-send our `AnnouncementSignatures` again on reconnect.
	PeerReceived,
}

/// A struct gathering data on a commitment, either local or remote.
struct CommitmentData<'a> {
	tx: CommitmentTransaction,
	htlcs_included: Vec<(HTLCOutputInCommitment, Option<&'a HTLCSource>)>, // the list of HTLCs (dust HTLCs *included*) which were not ignored when building the transaction
	outbound_htlc_preimages: Vec<PaymentPreimage>, // preimages for successful offered HTLCs since last commitment
	inbound_htlc_preimages: Vec<PaymentPreimage>, // preimages for successful received HTLCs since last commitment
}

/// A struct gathering stats on a commitment transaction, either local or remote.
#[derive(Debug, PartialEq)]
pub(crate) struct CommitmentStats {
	/// The total fee included in the commitment transaction
	pub commit_tx_fee_sat: u64,
	/// The local balance before fees *not* considering dust limits
	pub local_balance_before_fee_msat: u64,
	/// The remote balance before fees *not* considering dust limits
	pub remote_balance_before_fee_msat: u64,
}

/// A return value enum for get_update_fulfill_htlc. See UpdateFulfillCommitFetch variants for
/// description
enum UpdateFulfillFetch {
	NewClaim { monitor_update: ChannelMonitorUpdate, htlc_value_msat: u64, update_blocked: bool },
	DuplicateClaim {},
}

/// The return type of get_update_fulfill_htlc_and_commit.
pub enum UpdateFulfillCommitFetch {
	/// Indicates the HTLC fulfill is new, and either generated an update_fulfill message, placed
	/// it in the holding cell, or re-generated the update_fulfill message after the same claim was
	/// previously placed in the holding cell (and has since been removed).
	NewClaim {
		/// The ChannelMonitorUpdate which places the new payment preimage in the channel monitor
		monitor_update: ChannelMonitorUpdate,
		/// The value of the HTLC which was claimed, in msat.
		htlc_value_msat: u64,
	},
	/// Indicates the HTLC fulfill is duplicative and already existed either in the holding cell
	/// or has been forgotten (presumably previously claimed).
	DuplicateClaim {},
}

/// Error returned when processing an invalid interactive-tx message from our counterparty.
pub(super) struct InteractiveTxMsgError {
	/// The underlying error.
	pub(super) err: ChannelError,
	/// If a splice was in progress when processing the message, this contains the splice funding
	/// information for emitting a `SpliceNegotiationFailed` event.
	pub(super) splice_funding_failed: Option<SpliceFundingFailed>,
	/// The event reason to use if this error causes a `SpliceNegotiationFailed` event.
	pub(super) negotiation_failure_reason: Option<NegotiationFailureReason>,
}

impl InteractiveTxMsgError {
	fn new(err: ChannelError, splice_funding_failed: Option<SpliceFundingFailed>) -> Self {
		Self { err, splice_funding_failed, negotiation_failure_reason: None }
	}

	fn with_negotiation_failure_reason(mut self, reason: NegotiationFailureReason) -> Self {
		self.negotiation_failure_reason = Some(reason);
		self
	}

	pub(super) fn into_parts(
		self,
	) -> (ChannelError, Option<(SpliceFundingFailed, NegotiationFailureReason)>) {
		let Self { err, splice_funding_failed, negotiation_failure_reason } = self;
		let splice_failure = splice_funding_failed.map(|splice_funding_failed| {
			let reason =
				negotiation_failure_reason.unwrap_or_else(|| Self::reason_from_channel_error(&err));
			(splice_funding_failed, reason)
		});
		(err, splice_failure)
	}

	fn reason_from_channel_error(err: &ChannelError) -> NegotiationFailureReason {
		NegotiationFailureReason::NegotiationError { msg: format!("{:?}", err) }
	}
}

/// The return value of `monitor_updating_restored`
pub(super) struct MonitorRestoreUpdates {
	pub raa: Option<msgs::RevokeAndACK>,
	/// A `CommitmentUpdate` to be sent to our channel peer.
	pub commitment_update: Option<msgs::CommitmentUpdate>,
	pub commitment_order: RAACommitmentOrder,
	pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
	pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
	pub finalized_claimed_htlcs: Vec<(HTLCSource, Option<AttributionData>)>,
	/// Inbound update_adds that are now irrevocably committed to this channel and are ready for the
	/// onion to be processed in order to forward or receive the HTLC.
	pub pending_update_adds: Vec<msgs::UpdateAddHTLC>,
	pub funding_broadcastable: Option<Transaction>,
	pub channel_ready: Option<msgs::ChannelReady>,
	pub channel_ready_order: ChannelReadyOrder,
	pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
	pub funding_tx_signed: Option<FundingTxSigned>,
	/// The sources of outbound HTLCs that were forwarded and irrevocably committed on this channel
	/// (the outbound edge), along with their outbound amounts. Useful to store in the inbound HTLC
	/// to ensure it gets resolved.
	pub committed_outbound_htlc_sources: Vec<(HTLCPreviousHopData, u64)>,
	/// Whether the restoration changed serialized channel state that needs ChannelManager
	/// persistence.
	pub requires_channel_manager_persistence: bool,
}

/// The return value of `signer_maybe_unblocked`
pub(super) struct SignerResumeUpdates {
	pub commitment_update: Option<msgs::CommitmentUpdate>,
	pub revoke_and_ack: Option<msgs::RevokeAndACK>,
	pub open_channel: Option<msgs::OpenChannel>,
	pub accept_channel: Option<msgs::AcceptChannel>,
	pub funding_created: Option<msgs::FundingCreated>,
	pub funding_signed: Option<msgs::FundingSigned>,
	pub funding_tx_signed: Option<FundingTxSigned>,
	pub channel_ready: Option<msgs::ChannelReady>,
	pub order: RAACommitmentOrder,
	pub closing_signed: Option<msgs::ClosingSigned>,
	pub signed_closing_tx: Option<Transaction>,
	pub shutdown_result: Option<ShutdownResult>,
}

/// The return value of `channel_reestablish`
pub(super) struct ReestablishResponses {
	pub channel_ready: Option<msgs::ChannelReady>,
	pub channel_ready_order: ChannelReadyOrder,
	pub raa: Option<msgs::RevokeAndACK>,
	pub commitment_update: Option<msgs::CommitmentUpdate>,
	pub commitment_order: RAACommitmentOrder,
	pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
	pub shutdown_msg: Option<msgs::Shutdown>,
	pub tx_signatures: Option<(TxSignaturesOrder, msgs::TxSignatures)>,
	pub tx_abort: Option<msgs::TxAbort>,
	pub splice_locked: Option<msgs::SpliceLocked>,
	pub inferred_splice_locked: Option<msgs::SpliceLocked>,
}

/// The first message we send to our peer after connection
pub(super) enum ReconnectionMsg {
	Reestablish(msgs::ChannelReestablish),
	Open(OpenChannelMessage),
	None,
}

/// The result of a shutdown that should be handled.
#[must_use]
pub(crate) struct ShutdownResult {
	pub(crate) closure_reason: ClosureReason,
	/// A channel monitor update to apply.
	pub(crate) monitor_update: Option<(PublicKey, OutPoint, ChannelId, ChannelMonitorUpdate)>,
	/// A list of dropped outbound HTLCs that can safely be failed backwards immediately.
	pub(crate) dropped_outbound_htlcs: Vec<(HTLCSource, PaymentHash, PublicKey, ChannelId)>,
	/// An unbroadcasted batch funding transaction id. The closure of this channel should be
	/// propagated to the remainder of the batch.
	pub(crate) unbroadcasted_batch_funding_txid: Option<Txid>,
	pub(crate) channel_id: ChannelId,
	pub(crate) user_channel_id: u128,
	pub(crate) channel_capacity_satoshis: u64,
	pub(crate) counterparty_node_id: PublicKey,
	pub(crate) is_manual_broadcast: bool,
	pub(crate) unbroadcasted_funding_tx: Option<Transaction>,
	pub(crate) channel_funding_txo: Option<OutPoint>,
	pub(crate) last_local_balance_msat: u64,
	/// If any splices were in progress when the channel was shut down, this contains
	/// the splice funding information for emitting SpliceNegotiationFailed events. Both an
	/// active negotiation round and a contribution queued for a later round may fail at once.
	pub(crate) splice_funding_failed: Vec<SpliceFundingFailed>,
	/// A splice pending at closure because our funding signatures are ready to send.
	pub(crate) splice_funding_negotiated: Option<SpliceFundingNegotiated>,
}

/// The result of a peer disconnection.
pub(crate) struct DisconnectResult {
	pub(crate) is_resumable: bool,
	/// If a splice was in progress when the channel was shut down, this contains
	/// the splice funding information for emitting a SpliceNegotiationFailed event.
	pub(crate) splice_funding_failed: Option<SpliceFundingFailed>,
}

/// Tracks the transaction number, along with current and next commitment points.
/// This consolidates the logic to advance our commitment number and request new
/// commitment points from our signer.
#[derive(Debug, Copy, Clone)]
struct HolderCommitmentPoint {
	next_transaction_number: u64,
	current_point: Option<PublicKey>,
	next_point: PublicKey,
	pending_next_point: Option<PublicKey>,

	// Track the two latest revoked points such that we no longer need to reach a potentially async
	// signer on channel reestablish. We would otherwise need to retrieve one or both of these
	// points from the signer to verify the received
	// [`msgs::ChannelReestablish::your_last_per_commitment_secret`].
	previous_revoked_point: Option<PublicKey>,
	last_revoked_point: Option<PublicKey>,
}

impl HolderCommitmentPoint {
	#[rustfmt::skip]
	pub fn new<S: ChannelSigner>(signer: &S, secp_ctx: &Secp256k1<secp256k1::All>) -> Option<Self> {
		Some(HolderCommitmentPoint {
			next_transaction_number: INITIAL_COMMITMENT_NUMBER,
			previous_revoked_point: None,
			last_revoked_point: None,
			current_point: None,
			next_point: signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER, secp_ctx).ok()?,
			pending_next_point: signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, secp_ctx).ok(),
		})
	}

	pub fn can_advance(&self) -> bool {
		self.pending_next_point.is_some()
	}

	pub fn previous_revoked_point(&self) -> Option<PublicKey> {
		self.previous_revoked_point
	}

	pub fn last_revoked_point(&self) -> Option<PublicKey> {
		self.last_revoked_point
	}

	pub fn current_transaction_number(&self) -> u64 {
		self.next_transaction_number + 1
	}

	pub fn current_point(&self) -> Option<PublicKey> {
		self.current_point
	}

	pub fn next_transaction_number(&self) -> u64 {
		self.next_transaction_number
	}

	pub fn next_point(&self) -> PublicKey {
		self.next_point
	}

	/// If we are pending advancing the next commitment point, this method tries asking the signer
	/// again.
	pub fn try_resolve_pending<S: ChannelSigner, L: Logger>(
		&mut self, signer: &S, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L,
	) {
		if !self.can_advance() {
			let pending_next_point =
				signer.get_per_commitment_point(self.next_transaction_number - 1, secp_ctx);
			if let Ok(point) = pending_next_point {
				log_trace!(
					logger,
					"Retrieved per-commitment point {} for next advancement",
					self.next_transaction_number - 1
				);
				self.pending_next_point = Some(point);
			} else {
				log_trace!(
					logger,
					"Pending per-commitment point {} for next advancement",
					self.next_transaction_number - 1
				);
			}
		}
	}

	/// If we are not pending the next commitment point, this method advances the commitment number
	/// and requests the next commitment point from the signer. Returns `Ok` if we were able to
	/// advance our commitment number (even if we are still pending the next commitment point).
	///
	/// If our signer is not ready to provide the next commitment point, we will advance but won't
	/// be able to advance again immediately. Instead, this hould be tried again later in
	/// `signer_unblocked` via `try_resolve_pending`.
	///
	/// If our signer is ready to provide the next commitment point, the next call to `advance` will
	/// succeed.
	pub fn advance<S: ChannelSigner, L: Logger>(
		&mut self, signer: &S, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L,
	) -> Result<(), ()> {
		if let Some(next_point) = self.pending_next_point {
			*self = Self {
				next_transaction_number: self.next_transaction_number - 1,
				previous_revoked_point: self.last_revoked_point,
				last_revoked_point: self.current_point,
				current_point: Some(self.next_point),
				next_point,
				pending_next_point: None,
			};

			self.try_resolve_pending(signer, secp_ctx, logger);
			return Ok(());
		}
		Err(())
	}
}

/// If the majority of the channels funds are to the fundee and the initiator holds only just
/// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
/// initiator controls the feerate, if they then go to increase the channel fee, they may have no
/// balance but the fundee is unable to send a payment as the increase in fee more than drains
/// their reserve value. Thus, neither side can send a new HTLC and the channel becomes useless.
/// Thus, before sending an HTLC when we are the initiator, we check that the feerate can increase
/// by this multiple without hitting this case, before sending.
/// This multiple is effectively the maximum feerate "jump" we expect until more HTLCs flow over
/// the channel. Sadly, there isn't really a good number for this - if we expect to have no new
/// HTLCs for days we may need this to suffice for feerate increases across days, but that may
/// leave the channel less usable as we hold a bigger reserve.
#[cfg(any(fuzzing, test, feature = "_test_utils"))]
pub const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;
#[cfg(not(any(fuzzing, test, feature = "_test_utils")))]
pub(crate) const FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE: u64 = 2;

/// If we fail to see a funding transaction confirmed on-chain within this many blocks after the
/// channel creation on an inbound channel, we simply force-close and move on.
/// This constant is the one suggested in BOLT 2.
pub(crate) const FUNDING_CONF_DEADLINE_BLOCKS: u32 = 2016;

/// In case of a concurrent update_add_htlc proposed by our counterparty, we might
/// not have enough balance value remaining to cover the onchain cost of this new
/// HTLC weight. If this happens, our counterparty fails the reception of our
/// commitment_signed including this new HTLC due to infringement on the channel
/// reserve.
/// To prevent this case, we compute our outbound update_fee with an HTLC buffer of
/// size 2. However, if the number of concurrent update_add_htlc is higher, this still
/// leads to a channel force-close. Ultimately, this is an issue coming from the
/// design of LN state machines, allowing asynchronous updates.
pub(crate) const CONCURRENT_INBOUND_HTLC_FEE_BUFFER: u32 = 2;

/// When a channel is opened, we check that the funding amount is enough to pay for relevant
/// commitment transaction fees, with at least this many HTLCs present on the commitment
/// transaction (not counting the value of the HTLCs themselves).
pub(crate) const MIN_AFFORDABLE_HTLC_COUNT: usize = 4;

/// When a [`FundedChannel`] has its [`ChannelConfig`] updated, its existing one is stashed for up
/// to this number of ticks to allow forwarding HTLCs by nodes that have yet to receive the new
/// ChannelUpdate prompted by the config update. This value was determined as follows:
///
///   * The expected interval between ticks (1 minute).
///   * The average convergence delay of updates across the network, i.e., ~300 seconds on average
///    for a node to see an update as seen on `<https://arxiv.org/pdf/2205.12737.pdf>`.
///   * `EXPIRE_PREV_CONFIG_TICKS` = convergence_delay / tick_interval
pub(crate) const EXPIRE_PREV_CONFIG_TICKS: usize = 5;

/// The number of ticks that may elapse while we're waiting for a response before we attempt to
/// disconnect them.
///
/// See [`ChannelContext::sent_message_awaiting_response`] for more information.
pub(crate) const DISCONNECT_PEER_AWAITING_RESPONSE_TICKS: usize = 2;

/// The number of ticks that may elapse while we're waiting for an unfunded outbound/inbound channel
/// to be promoted to a [`FundedChannel`] since the unfunded channel was created. An unfunded channel
/// exceeding this age limit will be force-closed and purged from memory.
pub(crate) const UNFUNDED_CHANNEL_AGE_LIMIT_TICKS: usize = 60;

/// Number of blocks needed for an output from a coinbase transaction to be spendable.
pub(crate) const COINBASE_MATURITY: u32 = 100;

/// The number of blocks to wait for a channel_announcement to propagate such that payments using an
/// older SCID can still be relayed. Once the spend of the previous funding transaction has reached
/// this number of confirmations, the corresponding SCID will be forgotten.
///
/// Because HTLCs added prior to 0.1 which were waiting to be failed may reference a channel's
/// pre-splice SCID, we need to ensure this is at least the maximum number of blocks before an HTLC
/// gets failed-back due to a time-out. Luckily, in LDK prior to 0.2, this is enforced directly
/// when checking the incoming HTLC, and compared against `CLTV_FAR_FAR_AWAY` (which prior to LDK
/// 0.2, and still at the time of writing, is 14 * 24 * 6, i.e. two weeks).
///
/// Here we use four times that value to give us more time to fail an HTLC back (which does require
/// the user call [`ChannelManager::process_pending_htlc_forwards`]) just in case (if an HTLC has
/// been expired for 3 * 2 weeks our counterparty really should have closed the channel by now).
/// Holding on to stale SCIDs doesn't really cost us much as each one costs an on-chain splice to
/// generate anyway, so we might as well make this nearly arbitrarily long.
///
/// [`ChannelManager::process_pending_htlc_forwards`]: crate::ln::channelmanager::ChannelManager::process_pending_htlc_forwards
#[cfg(not(test))]
pub(crate) const CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY: u32 = 14 * 24 * 6 * 4;

/// In test (not `_test_utils`, though, since that tests actual upgrading), we deliberately break
/// the above condition so that we can ensure that HTLCs forwarded in 0.2 or later are handled
/// correctly even if this constant is reduced and an HTLC can outlive the original channel's SCID.
#[cfg(test)]
pub(crate) const CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY: u32 = 144;

#[derive(Debug)]
struct PendingChannelMonitorUpdate {
	update: ChannelMonitorUpdate,
}

impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
	(0, update, required),
});

/// A payment channel with a counterparty throughout its life-cycle, encapsulating negotiation and
/// funding phases.
pub(super) struct Channel<SP: SignerProvider> {
	phase: ChannelPhase<SP>,
}

/// The `ChannelPhase` enum describes the current phase in life of a lightning channel with each of
/// its variants containing an appropriate channel struct.
enum ChannelPhase<SP: SignerProvider> {
	Undefined,
	UnfundedOutboundV1(OutboundV1Channel<SP>),
	UnfundedInboundV1(InboundV1Channel<SP>),
	UnfundedV2(PendingV2Channel<SP>),
	Funded(FundedChannel<SP>),
}

impl<SP: SignerProvider> Channel<SP>
where
	SP::EcdsaSigner: ChannelSigner,
{
	pub fn context(&self) -> &ChannelContext<SP> {
		match &self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => &chan.context,
			ChannelPhase::UnfundedOutboundV1(chan) => &chan.context,
			ChannelPhase::UnfundedInboundV1(chan) => &chan.context,
			ChannelPhase::UnfundedV2(chan) => &chan.context,
		}
	}

	pub fn context_mut(&mut self) -> &mut ChannelContext<SP> {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => &mut chan.context,
			ChannelPhase::UnfundedOutboundV1(chan) => &mut chan.context,
			ChannelPhase::UnfundedInboundV1(chan) => &mut chan.context,
			ChannelPhase::UnfundedV2(chan) => &mut chan.context,
		}
	}

	pub fn funding(&self) -> &FundingScope {
		match &self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => &chan.funding,
			ChannelPhase::UnfundedOutboundV1(chan) => &chan.funding,
			ChannelPhase::UnfundedInboundV1(chan) => &chan.funding,
			ChannelPhase::UnfundedV2(chan) => &chan.funding,
		}
	}

	#[cfg(any(test, feature = "_externalize_tests"))]
	pub fn funding_mut(&mut self) -> &mut FundingScope {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => &mut chan.funding,
			ChannelPhase::UnfundedOutboundV1(chan) => &mut chan.funding,
			ChannelPhase::UnfundedInboundV1(chan) => &mut chan.funding,
			ChannelPhase::UnfundedV2(chan) => &mut chan.funding,
		}
	}

	pub fn funding_and_context_mut(&mut self) -> (&FundingScope, &mut ChannelContext<SP>) {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => (&chan.funding, &mut chan.context),
			ChannelPhase::UnfundedOutboundV1(chan) => (&chan.funding, &mut chan.context),
			ChannelPhase::UnfundedInboundV1(chan) => (&chan.funding, &mut chan.context),
			ChannelPhase::UnfundedV2(chan) => (&chan.funding, &mut chan.context),
		}
	}

	pub fn unfunded_context_mut(&mut self) -> Option<&mut UnfundedChannelContext> {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(_) => {
				debug_assert!(false);
				None
			},
			ChannelPhase::UnfundedOutboundV1(chan) => Some(&mut chan.unfunded_context),
			ChannelPhase::UnfundedInboundV1(chan) => Some(&mut chan.unfunded_context),
			ChannelPhase::UnfundedV2(chan) => Some(&mut chan.unfunded_context),
		}
	}

	pub fn is_funded(&self) -> bool {
		matches!(self.phase, ChannelPhase::Funded(_))
	}

	pub fn as_funded(&self) -> Option<&FundedChannel<SP>> {
		if let ChannelPhase::Funded(channel) = &self.phase {
			Some(channel)
		} else {
			None
		}
	}

	pub fn as_funded_mut(&mut self) -> Option<&mut FundedChannel<SP>> {
		if let ChannelPhase::Funded(channel) = &mut self.phase {
			Some(channel)
		} else {
			None
		}
	}

	pub fn as_unfunded_outbound_v1_mut(&mut self) -> Option<&mut OutboundV1Channel<SP>> {
		if let ChannelPhase::UnfundedOutboundV1(channel) = &mut self.phase {
			Some(channel)
		} else {
			None
		}
	}

	#[cfg(any(test, feature = "_externalize_tests"))]
	pub fn is_unfunded_v1(&self) -> bool {
		matches!(
			self.phase,
			ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_)
		)
	}

	/// Returns true if this channel is waiting on a (batch) funding transaction to be provided.
	///
	/// If this method returns true, [`Self::into_unfunded_outbound_v1`] will also succeed.
	pub fn ready_to_fund(&self) -> bool {
		if !self.funding().is_outbound() {
			return false;
		}
		match self.context().channel_state {
			ChannelState::NegotiatingFunding(flags) => {
				debug_assert!(matches!(self.phase, ChannelPhase::UnfundedOutboundV1(_)));
				flags.is_our_init_sent() && flags.is_their_init_sent()
			},
			_ => false,
		}
	}

	pub fn into_unfunded_outbound_v1(self) -> Result<OutboundV1Channel<SP>, Self> {
		if let ChannelPhase::UnfundedOutboundV1(channel) = self.phase {
			Ok(channel)
		} else {
			Err(self)
		}
	}

	pub fn into_unfunded_inbound_v1(self) -> Result<InboundV1Channel<SP>, Self> {
		if let ChannelPhase::UnfundedInboundV1(channel) = self.phase {
			Ok(channel)
		} else {
			Err(self)
		}
	}

	pub fn as_unfunded_v2(&self) -> Option<&PendingV2Channel<SP>> {
		if let ChannelPhase::UnfundedV2(channel) = &self.phase {
			Some(channel)
		} else {
			None
		}
	}

	#[rustfmt::skip]
	pub fn signer_maybe_unblocked<L: Logger, CBP>(
		&mut self, chain_hash: ChainHash, best_block_height: u32, logger: &L, path_for_release_htlc: CBP
	) -> Result<Option<SignerResumeUpdates>, ChannelError> where CBP: Fn(u64) -> BlindedMessagePath {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => chan.signer_maybe_unblocked(best_block_height, logger, path_for_release_htlc).map(|r| Some(r)),
			ChannelPhase::UnfundedOutboundV1(chan) => {
				let (open_channel, funding_created) = chan.signer_maybe_unblocked(chain_hash, logger);
				Ok(Some(SignerResumeUpdates {
					commitment_update: None,
					revoke_and_ack: None,
					open_channel,
					accept_channel: None,
					funding_created,
					funding_signed: None,
					funding_tx_signed: None,
					channel_ready: None,
					order: chan.context.resend_order.clone(),
					closing_signed: None,
					signed_closing_tx: None,
					shutdown_result: None,
				}))
			},
			ChannelPhase::UnfundedInboundV1(chan) => {
				let accept_channel = chan.signer_maybe_unblocked(logger);
				Ok(Some(SignerResumeUpdates {
					commitment_update: None,
					revoke_and_ack: None,
					open_channel: None,
					accept_channel,
					funding_created: None,
					funding_signed: None,
					funding_tx_signed: None,
					channel_ready: None,
					order: chan.context.resend_order.clone(),
					closing_signed: None,
					signed_closing_tx: None,
					shutdown_result: None,
				}))
			},
			ChannelPhase::UnfundedV2(_) => Ok(None),
		}
	}

	/// Should be called when the peer is disconnected. Returns true if the channel can be resumed
	/// when the peer reconnects (via [`Self::peer_connected_get_handshake`]). If not, the channel
	/// must be immediately closed.
	pub fn peer_disconnected_is_resumable<L: Logger>(&mut self, logger: &L) -> DisconnectResult {
		let is_resumable = match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => {
				chan.remove_uncommitted_htlcs_and_mark_paused(logger).is_ok()
			},
			// If we get disconnected and haven't yet committed to a funding
			// transaction, we can replay the `open_channel` on reconnection, so don't
			// bother dropping the channel here. However, if we already committed to
			// the funding transaction we don't yet support replaying the funding
			// handshake (and bailing if the peer rejects it), so we force-close in
			// that case.
			ChannelPhase::UnfundedOutboundV1(chan) => chan.is_resumable(),
			ChannelPhase::UnfundedInboundV1(_) => false,
			ChannelPhase::UnfundedV2(_) => false,
		};

		let splice_funding_failed = if let ChannelPhase::Funded(chan) = &mut self.phase {
			// Reset any quiescence-related state as it is implicitly terminated once disconnected.
			if matches!(chan.context.channel_state, ChannelState::ChannelReady(_)) {
				chan.context.channel_state.clear_local_stfu_sent();
				chan.context.channel_state.clear_remote_stfu_sent();
				if chan.should_reset_pending_splice_state(true) {
					// If there was a pending splice negotiation that failed due to disconnecting, we
					// also take the opportunity to clean up our state.
					let (splice_funding_failed, splice_funding_negotiated) =
						chan.reset_pending_splice_state();
					debug_assert!(splice_funding_negotiated.is_none());
					debug_assert!(!chan.context.channel_state.is_quiescent());
					splice_funding_failed
				} else if !chan.has_pending_splice_awaiting_signatures() {
					// We shouldn't be quiescent anymore upon reconnecting if:
					// - We were in quiescence but a splice/RBF was never negotiated or
					// - We were in quiescence but the splice negotiation failed due to disconnecting
					//
					// NOTE: While `exit_quiescence` clears the disconnect timer, it should already
					// have been cleared by `remove_uncommitted_htlcs_and_mark_paused`.
					chan.exit_quiescence();
					None
				} else {
					if let Some(FundingNegotiation::AwaitingSignatures {
						initial_commitment_signed_from_counterparty,
						..
					}) = chan
						.pending_splice
						.as_mut()
						.and_then(|pending_splice| pending_splice.funding_negotiation.as_mut())
					{
						initial_commitment_signed_from_counterparty.take();
					}
					None
				}
			} else {
				None
			}
		} else {
			None
		};

		DisconnectResult { is_resumable, splice_funding_failed }
	}

	/// Should be called when the peer re-connects, returning an initial message which we should
	/// send our peer to begin the channel reconnection process.
	#[rustfmt::skip]
	pub fn peer_connected_get_handshake<L: Logger>(
		&mut self, chain_hash: ChainHash, logger: &L,
	) -> ReconnectionMsg {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) =>
				ReconnectionMsg::Reestablish(chan.get_channel_reestablish(logger)),
			ChannelPhase::UnfundedOutboundV1(chan) => {
				chan.get_open_channel(chain_hash, logger)
					.map(|msg| ReconnectionMsg::Open(OpenChannelMessage::V1(msg)))
					.unwrap_or(ReconnectionMsg::None)
			},
			ChannelPhase::UnfundedInboundV1(_) => {
				// Since unfunded inbound channel maps are cleared upon disconnecting a peer,
				// they are not persisted and won't be recovered after a crash.
				// Therefore, they shouldn't exist at this point.
				debug_assert!(false);
				ReconnectionMsg::None
			},
			ChannelPhase::UnfundedV2(chan) => {
				if chan.funding.is_outbound() {
					ReconnectionMsg::Open(OpenChannelMessage::V2(
						chan.get_open_channel_v2(chain_hash)
					))
				} else {
					// Since unfunded inbound channel maps are cleared upon disconnecting a peer,
					// they are not persisted and won't be recovered after a crash.
					// Therefore, they shouldn't exist at this point.
					debug_assert!(false);
					ReconnectionMsg::None
				}
			},
		}
	}

	#[rustfmt::skip]
	pub fn maybe_handle_error_without_close<F: FeeEstimator, L: Logger>(
		&mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
		user_config: &UserConfig, their_features: &InitFeatures,
	) -> Result<Option<OpenChannelMessage>, ()> {
		match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(_) => Ok(None),
			ChannelPhase::UnfundedOutboundV1(chan) => {
				let logger = WithChannelContext::from(logger, &chan.context, None);
				chan.maybe_handle_error_without_close(
					chain_hash, fee_estimator, &&logger, user_config, their_features,
				)
					.map(|msg| Some(OpenChannelMessage::V1(msg)))
			},
			ChannelPhase::UnfundedInboundV1(_) => Ok(None),
			ChannelPhase::UnfundedV2(chan) => {
				if chan.funding.is_outbound() {
					chan.maybe_handle_error_without_close(
						chain_hash, fee_estimator, user_config, their_features,
					)
						.map(|msg| Some(OpenChannelMessage::V2(msg)))
				} else {
					Ok(None)
				}
			},
		}
	}

	fn interactive_tx_constructor_mut(&mut self) -> Option<&mut InteractiveTxConstructor> {
		match &mut self.phase {
			ChannelPhase::UnfundedV2(chan) => chan.interactive_tx_constructor.as_mut(),
			ChannelPhase::Funded(chan) => chan.interactive_tx_constructor_mut(),
			_ => None,
		}
	}

	fn interactive_tx_constructor_for_message(
		&mut self, msg_name: &str,
	) -> Result<&mut InteractiveTxConstructor, InteractiveTxMsgError> {
		if matches!(
			&self.phase,
			ChannelPhase::Funded(chan) if !chan.context.channel_state.is_quiescent()
		) {
			return Err(InteractiveTxMsgError::new(
				ChannelError::Ignore(format!("Ignoring unexpected {msg_name} while not quiescent")),
				None,
			));
		}
		match self.interactive_tx_constructor_mut() {
			Some(interactive_tx_constructor) => Ok(interactive_tx_constructor),
			None => Err(InteractiveTxMsgError::new(
				ChannelError::WarnAndDisconnect(format!("Received unexpected {msg_name}")),
				None,
			)),
		}
	}

	fn fail_interactive_tx_negotiation<L: Logger>(
		&mut self, reason: AbortReason, logger: &L,
	) -> InteractiveTxMsgError {
		let logger = WithChannelContext::from(logger, &self.context(), None);
		log_info!(logger, "Failed interactive transaction negotiation: {reason}");

		let splice_funding_failed = match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_) => None,
			ChannelPhase::UnfundedV2(pending_v2_channel) => {
				pending_v2_channel.interactive_tx_constructor.take();
				None
			},
			ChannelPhase::Funded(funded_channel) => {
				if funded_channel.should_reset_pending_splice_state(true) {
					let (splice_funding_failed, splice_funding_negotiated) =
						funded_channel.reset_pending_splice_state();
					debug_assert!(splice_funding_negotiated.is_none());
					splice_funding_failed
				} else {
					debug_assert!(false, "We should never fail an interactive funding negotiation once we're exchanging tx_signatures");
					None
				}
			},
		};

		InteractiveTxMsgError::new(ChannelError::Abort(reason), splice_funding_failed)
	}

	pub fn tx_add_input<L: Logger>(
		&mut self, msg: &msgs::TxAddInput, logger: &L,
	) -> Result<InteractiveTxMessageSend, InteractiveTxMsgError> {
		self.interactive_tx_constructor_for_message("tx_add_input")?
			.handle_tx_add_input(msg)
			.map_err(|reason| self.fail_interactive_tx_negotiation(reason, logger))
	}

	pub fn tx_add_output<L: Logger>(
		&mut self, msg: &msgs::TxAddOutput, logger: &L,
	) -> Result<InteractiveTxMessageSend, InteractiveTxMsgError> {
		self.interactive_tx_constructor_for_message("tx_add_output")?
			.handle_tx_add_output(msg)
			.map_err(|reason| self.fail_interactive_tx_negotiation(reason, logger))
	}

	pub fn tx_remove_input<L: Logger>(
		&mut self, msg: &msgs::TxRemoveInput, logger: &L,
	) -> Result<InteractiveTxMessageSend, InteractiveTxMsgError> {
		self.interactive_tx_constructor_for_message("tx_remove_input")?
			.handle_tx_remove_input(msg)
			.map_err(|reason| self.fail_interactive_tx_negotiation(reason, logger))
	}

	pub fn tx_remove_output<L: Logger>(
		&mut self, msg: &msgs::TxRemoveOutput, logger: &L,
	) -> Result<InteractiveTxMessageSend, InteractiveTxMsgError> {
		self.interactive_tx_constructor_for_message("tx_remove_output")?
			.handle_tx_remove_output(msg)
			.map_err(|reason| self.fail_interactive_tx_negotiation(reason, logger))
	}

	pub fn tx_complete<F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::TxComplete, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<TxCompleteResult, InteractiveTxMsgError> {
		let tx_complete_action = self
			.interactive_tx_constructor_for_message("tx_complete")?
			.handle_tx_complete(msg)
			.map_err(|reason| self.fail_interactive_tx_negotiation(reason, logger))?;

		let (interactive_tx_msg_send, negotiation_complete) = match tx_complete_action {
			HandleTxCompleteValue::SendTxMessage(interactive_tx_msg_send) => {
				(Some(interactive_tx_msg_send), None)
			},
			HandleTxCompleteValue::NegotiationComplete(
				interactive_tx_msg_send,
				funding_outpoint,
			) => (interactive_tx_msg_send, Some(funding_outpoint)),
		};

		let funding_outpoint = if let Some(funding_outpoint) = negotiation_complete {
			funding_outpoint
		} else {
			return Ok(TxCompleteResult {
				interactive_tx_msg_send,
				event_unsigned_tx: None,
				funding_tx_signed: None,
			});
		};

		self.funding_tx_constructed(funding_outpoint)
			.map_err(|abort_reason| self.fail_interactive_tx_negotiation(abort_reason, logger))?;

		let signing_session = self
			.context()
			.interactive_tx_signing_session
			.as_ref()
			.expect("The signing session must have been initialized in funding_tx_constructed");
		let has_local_contribution = signing_session.has_local_contribution();

		let event_unsigned_tx =
			has_local_contribution.then(|| signing_session.unsigned_tx().tx().clone());

		let funding_tx_signed = if !has_local_contribution {
			let funding_txid = signing_session.unsigned_tx().tx().compute_txid();
			self.funding_transaction_signed(funding_txid, vec![], 0, fee_estimator, logger)
				.map(Some)
				.map_err(|err| {
					log_error!(
						logger,
						"Failed signing funding transaction without local contribution: {err:?}"
					);
					self.fail_interactive_tx_negotiation(
						AbortReason::InternalError("Signing failed"),
						logger,
					)
				})?
		} else {
			None
		};

		Ok(TxCompleteResult { interactive_tx_msg_send, event_unsigned_tx, funding_tx_signed })
	}

	pub fn tx_abort<L: Logger>(
		&mut self, msg: &msgs::TxAbort, logger: &L,
	) -> Result<(Option<msgs::TxAbort>, Option<SpliceFundingFailed>), ChannelError> {
		// If we have not sent a `tx_abort` message for this negotiation previously, we need to echo
		// back a tx_abort message according to the spec:
		//   https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L560-L561
		// For rationale why we echo back `tx_abort`:
		//   https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L578-L580
		let (should_ack, splice_funding_failed) = match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_) => {
				let err = "Got an unexpected tx_abort message: This is an unfunded channel created with V1 channel establishment";
				return Err(ChannelError::Warn(err.into()));
			},
			ChannelPhase::UnfundedV2(pending_v2_channel) => {
				let had_constructor =
					pending_v2_channel.interactive_tx_constructor.take().is_some();
				(had_constructor, None)
			},
			ChannelPhase::Funded(funded_channel) => {
				if funded_channel.has_pending_splice_awaiting_signatures()
					&& funded_channel
						.context()
						.interactive_tx_signing_session
						.as_ref()
						.expect("We have a pending splice awaiting signatures")
						.has_received_commitment_signed()
				{
					// We only force close once the counterparty tries to abort after committing to
					// the splice via their initial `commitment_signed`. This is because our monitor
					// state is updated with the post-splice commitment transaction upon receiving
					// their `commitment_signed`, so we would need another monitor update to abandon
					// it, which we don't currently support.
					return Err(ChannelError::close(
						"Received tx_abort while awaiting tx_signatures exchange".to_owned(),
					));
				}
				if funded_channel.should_reset_pending_splice_state(false) {
					let has_funding_negotiation = funded_channel
						.pending_splice
						.as_ref()
						.map(|pending_splice| pending_splice.funding_negotiation.is_some())
						.unwrap_or(false);
					debug_assert!(has_funding_negotiation);
					let (splice_funding_failed, splice_funding_negotiated) =
						funded_channel.reset_pending_splice_state();
					debug_assert!(splice_funding_negotiated.is_none());
					(true, splice_funding_failed)
				} else {
					// We were not tracking the pending funding negotiation state anymore, likely
					// due to a disconnection or already having sent our own `tx_abort`.
					(false, None)
				}
			},
		};

		let tx_abort = should_ack.then(|| {
			let logger = WithChannelContext::from(logger, &self.context(), None);
			let reason = String::from_utf8_lossy(&msg.data);
			log_info!(
				logger,
				"Counterparty failed interactive transaction negotiation: {}",
				log_msg!(reason)
			);
			msgs::TxAbort {
				channel_id: msg.channel_id,
				data: "Acknowledged tx_abort".to_string().into_bytes(),
			}
		});

		Ok((tx_abort, splice_funding_failed))
	}

	#[rustfmt::skip]
	pub fn funding_signed<L: Logger>(
		&mut self, msg: &msgs::FundingSigned, best_block: BlockLocator, signer_provider: &SP, logger: &L
	) -> Result<(&mut FundedChannel<SP>, ChannelMonitor<SP::EcdsaSigner>), ChannelError> {
		let phase = core::mem::replace(&mut self.phase, ChannelPhase::Undefined);
		let result = if let ChannelPhase::UnfundedOutboundV1(chan) = phase {
			let channel_state = chan.context.channel_state;
			let logger = WithChannelContext::from(logger, &chan.context, None);
			match chan.funding_signed(msg, best_block, signer_provider, &&logger) {
				Ok((chan, monitor)) => {
					debug_assert!(matches!(chan.context.channel_state, ChannelState::AwaitingChannelReady(_)));
					self.phase = ChannelPhase::Funded(chan);
					Ok(monitor)
				},
				Err((chan, e)) => {
					debug_assert_eq!(chan.context.channel_state, channel_state);
					self.phase = ChannelPhase::UnfundedOutboundV1(chan);
					Err(e)
				},
			}
		} else {
			self.phase = phase;
			Err(ChannelError::SendError("Failed to find corresponding UnfundedOutboundV1 channel".to_owned()))
		};

		debug_assert!(!matches!(self.phase, ChannelPhase::Undefined));
		result.map(|monitor| (self.as_funded_mut().expect("Channel should be funded"), monitor))
	}

	fn funding_tx_constructed(&mut self, funding_outpoint: OutPoint) -> Result<(), AbortReason> {
		let interactive_tx_constructor = match &mut self.phase {
			ChannelPhase::UnfundedV2(chan) => {
				debug_assert_eq!(
					chan.context.channel_state,
					ChannelState::NegotiatingFunding(
						NegotiatingFundingFlags::OUR_INIT_SENT
							| NegotiatingFundingFlags::THEIR_INIT_SENT
					),
				);
				chan.context.assert_no_commitment_advancement(
					chan.unfunded_context.transaction_number(),
					"initial commitment_signed",
				);

				chan.context.channel_state =
					ChannelState::FundingNegotiated(FundingNegotiatedFlags::new());
				chan.funding.channel_transaction_parameters.funding_outpoint =
					Some(funding_outpoint);

				chan.interactive_tx_constructor
					.take()
					.expect("PendingV2Channel::interactive_tx_constructor should be set")
			},
			ChannelPhase::Funded(chan) => {
				if let Some(pending_splice) = chan.pending_splice.as_mut() {
					let funding_negotiation = pending_splice.funding_negotiation.take();
					if let Some(FundingNegotiation::ConstructingTransaction {
						mut funding,
						funding_feerate_sat_per_1000_weight,
						interactive_tx_constructor,
					}) = funding_negotiation
					{
						let is_initiator = interactive_tx_constructor.is_initiator();
						funding.channel_transaction_parameters.funding_outpoint =
							Some(funding_outpoint);
						pending_splice.funding_negotiation =
							Some(FundingNegotiation::AwaitingSignatures {
								is_initiator,
								funding,
								funding_feerate_sat_per_1000_weight,
								initial_commitment_signed_from_counterparty: None,
							});
						interactive_tx_constructor
					} else {
						// Replace the taken state for later error handling
						pending_splice.funding_negotiation = funding_negotiation;
						return Err(AbortReason::InternalError(
							"Got a tx_complete message in an invalid state",
						));
					}
				} else {
					return Err(AbortReason::InternalError(
						"Got a tx_complete message in an invalid state",
					));
				}
			},
			_ => {
				debug_assert!(false);
				return Err(AbortReason::InternalError(
					"Got a tx_complete message in an invalid phase",
				));
			},
		};

		let signing_session = interactive_tx_constructor.into_signing_session();
		self.context_mut().interactive_tx_signing_session = Some(signing_session);
		Ok(())
	}

	pub fn funding_transaction_signed<F: FeeEstimator, L: Logger>(
		&mut self, funding_txid_signed: Txid, witnesses: Vec<Witness>, best_block_height: u32,
		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<FundingTxSigned, APIError> {
		let (context, funding, pending_splice) = match &mut self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::UnfundedV2(channel) => (&mut channel.context, &channel.funding, None),
			ChannelPhase::Funded(channel) => {
				(&mut channel.context, &channel.funding, channel.pending_splice.as_ref())
			},
			_ => {
				return Err(APIError::APIMisuseError {
					err: format!(
						"Channel with id {} not expecting funding signatures",
						self.context().channel_id
					),
				});
			},
		};

		let signing_session = if let Some(signing_session) =
			context.interactive_tx_signing_session.as_mut()
		{
			if let Some(pending_splice) = pending_splice.as_ref() {
				debug_assert!(pending_splice
					.funding_negotiation
					.as_ref()
					.map(|funding_negotiation| matches!(
						funding_negotiation,
						FundingNegotiation::AwaitingSignatures { .. }
					))
					.unwrap_or(false));
			}

			if signing_session.has_holder_witnesses() {
				return Ok(FundingTxSigned {
					commitment_signed: None,
					counterparty_initial_commitment_signed_result: None,
					tx_signatures: None,
					funding_tx: None,
					splice_negotiated: None,
					splice_locked: None,
				});
			}

			signing_session
		} else {
			if Some(funding_txid_signed) == funding.get_funding_txid() {
				// We may be handling a duplicate call and the funding was already locked so we
				// no longer have the signing session present.
				return Ok(FundingTxSigned {
					commitment_signed: None,
					counterparty_initial_commitment_signed_result: None,
					tx_signatures: None,
					funding_tx: None,
					splice_negotiated: None,
					splice_locked: None,
				});
			}
			let err = format!("Channel {} not expecting funding signatures", context.channel_id);
			return Err(APIError::APIMisuseError { err });
		};

		let (mut tx_signatures, mut funding_tx) = signing_session
			.provide_holder_witnesses(
				context.channel_id,
				funding_txid_signed,
				witnesses,
				&context.secp_ctx,
			)
			.map_err(|err| APIError::APIMisuseError { err })?;

		debug_assert_eq!(
			pending_splice.is_some(),
			signing_session.unsigned_tx().shared_input_index().is_some()
		);
		if let Some(splice_input_index) = signing_session.unsigned_tx().shared_input_index() {
			let sig = context
				.holder_signer
				.sign_splice_shared_input(
					&funding.channel_transaction_parameters,
					signing_session.unsigned_tx().tx(),
					splice_input_index as usize,
					&context.secp_ctx,
				)
				.ok();
			if let Some(sig) = sig {
				(tx_signatures, funding_tx) = signing_session
					.provide_holder_shared_input_signature(sig)
					.map_err(|err| APIError::APIMisuseError { err })?;
			} else {
				log_debug!(
					logger,
					"Splice shared input signature not available, waiting on async signer"
				);
				debug_assert!(tx_signatures.is_none());
				debug_assert!(funding_tx.is_none());
			}
		}

		let logger = WithChannelContext::from(logger, &context, None);
		if tx_signatures.is_some() {
			log_info!(
				logger,
				"Sending tx_signatures for interactive funding transaction {funding_txid_signed}"
			);
		}

		let funding = pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
			.and_then(|funding_negotiation| funding_negotiation.as_funding())
			.unwrap_or(funding);
		let commitment_signed = context.get_initial_commitment_signed_v2(funding, &&logger);

		let mut funding_tx_signed = FundingTxSigned {
			commitment_signed,
			counterparty_initial_commitment_signed_result: None,
			tx_signatures,
			funding_tx: None,
			splice_negotiated: None,
			splice_locked: None,
		};

		// If we have a pending splice with a buffered initial commitment signed from our
		// counterparty, process it now that we have provided our signatures.
		funding_tx_signed.counterparty_initial_commitment_signed_result =
			self.as_funded_mut().and_then(|funded_channel| {
				funded_channel
					.pending_splice
					.as_mut()
					.and_then(|pending_splice| pending_splice.funding_negotiation.as_mut())
					.and_then(|funding_negotiation| {
						if let FundingNegotiation::AwaitingSignatures {
							ref mut initial_commitment_signed_from_counterparty,
							..
						} = funding_negotiation
						{
							initial_commitment_signed_from_counterparty.take()
						} else {
							None
						}
					})
					.map(|commit_sig| {
						funded_channel.splice_initial_commitment_signed(
							&commit_sig,
							fee_estimator,
							&&logger,
						)
					})
			});

		// For zero conf channels, we don't expect the funding transaction to be ready for broadcast
		// yet as, according to the spec, our counterparty shouldn't have sent their `tx_signatures`
		// without us having sent our initial commitment signed to them first. However, in the event
		// they do, we choose to handle it anyway. Note that because of this behavior not being
		// spec-compliant, we're not able to test this without custom logic.
		if let Some(funding_tx) = funding_tx {
			debug_assert!(funding_tx_signed.tx_signatures.is_some());
			let funded_channel = self.as_funded_mut().expect(
				"Funding transactions ready for broadcast can only exist for funded channels",
			);
			funded_channel.on_tx_signatures_exchange(
				&mut funding_tx_signed,
				funding_tx,
				best_block_height,
				&logger,
			)
		};

		Ok(funding_tx_signed)
	}

	pub fn force_shutdown(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
		let (funding, context) = self.funding_and_context_mut();
		context.force_shutdown(funding, closure_reason)
	}

	#[rustfmt::skip]
	pub fn commitment_signed<F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::CommitmentSigned, best_block: BlockLocator, signer_provider: &SP, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
	) -> Result<(Option<ChannelMonitor<SP::EcdsaSigner>>, Option<ChannelMonitorUpdate>), ChannelError> {
		let phase = core::mem::replace(&mut self.phase, ChannelPhase::Undefined);
		match phase {
			ChannelPhase::UnfundedV2(chan) => {
				let holder_commitment_point = match chan.unfunded_context.holder_commitment_point {
					Some(point) => point,
					None => {
						let channel_id = chan.context.channel_id();
						// TODO(dual_funding): Add async signing support.
						return Err( ChannelError::close(
							format!("Expected to have holder commitment points available upon finishing interactive tx construction for channel {}",
								channel_id)));
					}
				};
				let mut funded_channel = FundedChannel {
					funding: chan.funding,
					context: chan.context,
					holder_commitment_point,
					pending_splice: None,
					quiescent_action: None,
				};
				let res = funded_channel.initial_commitment_signed_v2(msg, best_block, signer_provider, logger)
					.map(|monitor| (Some(monitor), None))
					// TODO: Change to `inspect_err` when MSRV is high enough.
					.map_err(|err| {
						// We always expect a `ChannelError` close.
						debug_assert!(matches!(err, ChannelError::Close(_)));
						err
					});
				self.phase = ChannelPhase::Funded(funded_channel);
				res
			},
			ChannelPhase::Funded(mut funded_channel) => {
				let has_negotiated_pending_splice = funded_channel.pending_splice.as_ref()
					.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
					.filter(|funding_negotiation| {
						matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures { .. })
					})
					.map(|funding_negotiation| funding_negotiation.as_funding().is_some())
					.unwrap_or(false);
				let session_received_commitment_signed = funded_channel
					.context
					.interactive_tx_signing_session
					.as_ref()
					.map(|session| session.has_received_commitment_signed())
					// Not having a signing session implies they've already sent `splice_locked`,
					// which must always come after the initial commitment signed is sent.
					.unwrap_or(true);
				let res = if has_negotiated_pending_splice && !session_received_commitment_signed {
					let has_holder_witnesses = funded_channel
						.context
						.interactive_tx_signing_session
						.as_ref()
						.map(|session| session.has_holder_witnesses())
						.unwrap_or(false);

					// We delay processing this until the user manually approves the splice via
					// [`Channel::funding_transaction_signed`], as otherwise, it would prevent the
					// user from canceling their contribution if they no longer wish to proceed.
					if has_holder_witnesses {
						funded_channel
							.splice_initial_commitment_signed(msg, fee_estimator, logger)
							.map(|monitor_update_opt| (None, monitor_update_opt))
					} else {
						let pending_splice = funded_channel.pending_splice.as_mut()
							.expect("We have a pending splice negotiated");
						let funding_negotiation = pending_splice.funding_negotiation.as_mut()
							.expect("We have a pending splice negotiated");
						log_debug!(logger, "Stashing counterparty initial commitment_signed to process after funding_transaction_signed");
						if let FundingNegotiation::AwaitingSignatures {
							ref mut initial_commitment_signed_from_counterparty, ..
						} = funding_negotiation {
							*initial_commitment_signed_from_counterparty = Some(msg.clone());
						}
						Ok((None, None))
					}
				} else {
					funded_channel.commitment_signed(msg, fee_estimator, logger)
						.map(|monitor_update_opt| (None, monitor_update_opt))
				};

				self.phase = ChannelPhase::Funded(funded_channel);
				res
			},
			_ => {
				self.phase = phase;
				debug_assert!(!matches!(self.phase, ChannelPhase::Undefined));
				Err(ChannelError::close("Got a commitment_signed message for an unfunded V1 channel!".into()))
			}
		}
	}

	/// Gets the available balances, see [`AvailableBalances`]'s fields for more info.
	///
	/// Returns `Err` if some party cannot currently pay for the HTLCs outbound from said party, and the anchors and
	/// transaction fee if they are the funder.
	pub fn get_available_balances<F: FeeEstimator>(
		&self, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<AvailableBalances, ()> {
		match &self.phase {
			ChannelPhase::Undefined => unreachable!(),
			ChannelPhase::Funded(chan) => chan.get_available_balances(fee_estimator),
			ChannelPhase::UnfundedOutboundV1(chan) => {
				chan.context.get_available_balances_for_scope(&chan.funding, fee_estimator)
			},
			ChannelPhase::UnfundedInboundV1(chan) => {
				chan.context.get_available_balances_for_scope(&chan.funding, fee_estimator)
			},
			ChannelPhase::UnfundedV2(chan) => {
				chan.context.get_available_balances_for_scope(&chan.funding, fee_estimator)
			},
		}
	}

	pub fn minimum_depth(&self) -> Option<u32> {
		self.context().minimum_depth(self.funding())
	}
}

impl<SP: SignerProvider> From<OutboundV1Channel<SP>> for Channel<SP>
where
	SP::EcdsaSigner: ChannelSigner,
{
	fn from(channel: OutboundV1Channel<SP>) -> Self {
		Channel { phase: ChannelPhase::UnfundedOutboundV1(channel) }
	}
}

impl<SP: SignerProvider> From<InboundV1Channel<SP>> for Channel<SP>
where
	SP::EcdsaSigner: ChannelSigner,
{
	fn from(channel: InboundV1Channel<SP>) -> Self {
		Channel { phase: ChannelPhase::UnfundedInboundV1(channel) }
	}
}

impl<SP: SignerProvider> From<PendingV2Channel<SP>> for Channel<SP>
where
	SP::EcdsaSigner: ChannelSigner,
{
	fn from(channel: PendingV2Channel<SP>) -> Self {
		Channel { phase: ChannelPhase::UnfundedV2(channel) }
	}
}

impl<SP: SignerProvider> From<FundedChannel<SP>> for Channel<SP>
where
	SP::EcdsaSigner: ChannelSigner,
{
	fn from(channel: FundedChannel<SP>) -> Self {
		Channel { phase: ChannelPhase::Funded(channel) }
	}
}

/// Contains all state common to unfunded inbound/outbound channels.
pub(super) struct UnfundedChannelContext {
	/// A counter tracking how many ticks have elapsed since this unfunded channel was
	/// created. If this unfunded channel reaches peer has yet to respond after reaching
	/// `UNFUNDED_CHANNEL_AGE_LIMIT_TICKS`, it will be force-closed and purged from memory.
	///
	/// This is so that we don't keep channels around that haven't progressed to a funded state
	/// in a timely manner.
	unfunded_channel_age_ticks: usize,
	/// Tracks the commitment number and commitment point before the channel is funded.
	holder_commitment_point: Option<HolderCommitmentPoint>,
}

impl UnfundedChannelContext {
	/// Determines whether we should force-close and purge this unfunded channel from memory due to it
	/// having reached the unfunded channel age limit.
	///
	/// This should be called on every [`super::channelmanager::ChannelManager::timer_tick_occurred`].
	pub fn should_expire_unfunded_channel(&mut self) -> bool {
		self.unfunded_channel_age_ticks += 1;
		self.unfunded_channel_age_ticks >= UNFUNDED_CHANNEL_AGE_LIMIT_TICKS
	}

	fn transaction_number(&self) -> u64 {
		self.holder_commitment_point
			.as_ref()
			.map(|point| point.next_transaction_number())
			.unwrap_or(INITIAL_COMMITMENT_NUMBER)
	}
}

/// Information pertaining to an attempt at funding the channel. This is typically constructed
/// during channel establishment and may be replaced during channel splicing or if the attempted
/// funding transaction is replaced using tx_init_rbf.
#[derive(Debug)]
pub(super) struct FundingScope {
	value_to_self_msat: u64, // Excluding all pending_htlcs, fees, and anchor outputs

	/// minimum channel reserve for self to maintain - set by them.
	#[cfg(any(test, feature = "_externalize_tests"))]
	pub(super) counterparty_selected_channel_reserve_satoshis: Option<u64>,
	#[cfg(not(any(test, feature = "_externalize_tests")))]
	counterparty_selected_channel_reserve_satoshis: Option<u64>,

	#[cfg(any(test, feature = "_externalize_tests"))]
	pub(super) holder_selected_channel_reserve_satoshis: u64,
	#[cfg(not(any(test, feature = "_externalize_tests")))]
	holder_selected_channel_reserve_satoshis: u64,

	#[cfg(debug_assertions)]
	/// Max to_local and to_remote outputs in a locally-generated commitment transaction
	holder_prev_commitment_tx_balance: Mutex<(u64, u64)>,
	#[cfg(debug_assertions)]
	/// Max to_local and to_remote outputs in a remote-generated commitment transaction
	counterparty_prev_commitment_tx_balance: Mutex<(u64, u64)>,

	// We save these values so we can make sure validation of channel updates properly predicts
	// what the next commitment transaction fee will be, by comparing the cached values to the
	// fee of the transaction generated by `build_commitment_transaction`.
	#[cfg(any(test, fuzzing))]
	next_local_fee: Mutex<PredictedNextFee>,
	#[cfg(any(test, fuzzing))]
	next_remote_fee: Mutex<PredictedNextFee>,

	pub(super) channel_transaction_parameters: ChannelTransactionParameters,

	/// The transaction which funds this channel. Note that for manually-funded channels (i.e.,
	/// [`ChannelContext::is_manual_broadcast`] is true) this will be a dummy empty transaction.
	funding_transaction: Option<Transaction>,
	/// The hash of the block in which the funding transaction was included.
	funding_tx_confirmed_in: Option<BlockHash>,
	funding_tx_confirmation_height: u32,
	short_channel_id: Option<u64>,

	/// The minimum number of confirmations before the funding is locked. If set, this will override
	/// [`ChannelContext::minimum_depth`].
	minimum_depth_override: Option<u32>,
}

impl Writeable for FundingScope {
	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
		write_tlv_fields!(writer, {
			(1, self.value_to_self_msat, required),
			(3, self.counterparty_selected_channel_reserve_satoshis, option),
			(5, self.holder_selected_channel_reserve_satoshis, required),
			(7, self.channel_transaction_parameters, (required: ReadableArgs, None)),
			(9, self.funding_transaction, option),
			(11, self.funding_tx_confirmed_in, option),
			(13, self.funding_tx_confirmation_height, required),
			(15, self.short_channel_id, option),
			(17, self.minimum_depth_override, option),
		});
		Ok(())
	}
}

impl Readable for FundingScope {
	#[rustfmt::skip]
	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
		let mut value_to_self_msat = RequiredWrapper(None);
		let mut counterparty_selected_channel_reserve_satoshis = None;
		let mut holder_selected_channel_reserve_satoshis = RequiredWrapper(None);
		let mut channel_transaction_parameters = RequiredWrapper(None);
		let mut funding_transaction = None;
		let mut funding_tx_confirmed_in = None;
		let mut funding_tx_confirmation_height = RequiredWrapper(None);
		let mut short_channel_id = None;
		let mut minimum_depth_override = None;

		read_tlv_fields!(reader, {
			(1, value_to_self_msat, required),
			(3, counterparty_selected_channel_reserve_satoshis, option),
			(5, holder_selected_channel_reserve_satoshis, required),
			(7, channel_transaction_parameters, (required: ReadableArgs, None)),
			(9, funding_transaction, option),
			(11, funding_tx_confirmed_in, option),
			(13, funding_tx_confirmation_height, required),
			(15, short_channel_id, option),
			(17, minimum_depth_override, option),
		});

		Ok(Self {
			value_to_self_msat: value_to_self_msat.0.unwrap(),
			counterparty_selected_channel_reserve_satoshis,
			holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.0.unwrap(),
			#[cfg(debug_assertions)]
			holder_prev_commitment_tx_balance: Mutex::new((0, 0)),
			#[cfg(debug_assertions)]
			counterparty_prev_commitment_tx_balance: Mutex::new((0, 0)),
			channel_transaction_parameters: channel_transaction_parameters.0.unwrap(),
			funding_transaction,
			funding_tx_confirmed_in,
			funding_tx_confirmation_height: funding_tx_confirmation_height.0.unwrap(),
			short_channel_id,
			minimum_depth_override,
			#[cfg(any(test, fuzzing))]
			next_local_fee: Mutex::new(PredictedNextFee::default()),
			#[cfg(any(test, fuzzing))]
			next_remote_fee: Mutex::new(PredictedNextFee::default()),
		})
	}
}

impl FundingScope {
	pub fn get_value_satoshis(&self) -> u64 {
		self.channel_transaction_parameters.channel_value_satoshis
	}

	pub(crate) fn get_value_to_self_msat(&self) -> u64 {
		self.value_to_self_msat
	}

	pub fn get_holder_counterparty_selected_channel_reserve_satoshis(&self) -> (u64, Option<u64>) {
		(
			self.holder_selected_channel_reserve_satoshis,
			self.counterparty_selected_channel_reserve_satoshis,
		)
	}

	fn get_htlc_maximum_msat(&self, party_max_htlc_value_in_flight_msat: u64) -> Option<u64> {
		self.counterparty_selected_channel_reserve_satoshis.map(|counterparty_reserve| {
			let holder_reserve = self.holder_selected_channel_reserve_satoshis;
			cmp::min(
				(self.get_value_satoshis() - counterparty_reserve - holder_reserve) * 1000,
				party_max_htlc_value_in_flight_msat,
			)
		})
	}

	pub fn is_outbound(&self) -> bool {
		self.channel_transaction_parameters.is_outbound_from_holder
	}

	/// Returns the funding_txo we either got from our peer, or were given by
	/// get_funding_created.
	pub fn get_funding_txo(&self) -> Option<OutPoint> {
		self.channel_transaction_parameters.funding_outpoint
	}

	/// Gets the funding output for this channel, if available.
	///
	/// When a channel is spliced, this continues to refer to the original funding output (which
	/// was spent by the splice transaction) until the splice transaction reaches sufficient
	/// confirmations to be locked (and we exchange `splice_locked` messages with our peer).
	pub fn get_funding_output(&self) -> Option<TxOut> {
		self.channel_transaction_parameters.make_funding_redeemscript_opt().map(|redeem_script| {
			TxOut {
				value: Amount::from_sat(self.get_value_satoshis()),
				script_pubkey: redeem_script.to_p2wsh(),
			}
		})
	}

	fn get_funding_txid(&self) -> Option<Txid> {
		self.channel_transaction_parameters.funding_outpoint.map(|txo| txo.txid)
	}

	fn get_holder_selected_contest_delay(&self) -> u16 {
		self.channel_transaction_parameters.holder_selected_contest_delay
	}

	fn get_holder_pubkeys(&self) -> &ChannelPublicKeys {
		&self.channel_transaction_parameters.holder_pubkeys
	}

	pub fn get_counterparty_selected_contest_delay(&self) -> Option<u16> {
		let params_opt = self.channel_transaction_parameters.counterparty_parameters.as_ref();
		params_opt.map(|params| params.selected_contest_delay)
	}

	fn get_counterparty_pubkeys(&self) -> &ChannelPublicKeys {
		&self.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
	}

	/// Gets the redeemscript for the funding transaction output (ie the funding transaction output
	/// pays to get_funding_redeemscript().to_p2wsh()).
	/// Panics if called before accept_channel/InboundV1Channel::new
	pub fn get_funding_redeemscript(&self) -> ScriptBuf {
		self.channel_transaction_parameters.make_funding_redeemscript()
	}

	fn holder_funding_pubkey(&self) -> &PublicKey {
		&self.get_holder_pubkeys().funding_pubkey
	}

	fn counterparty_funding_pubkey(&self) -> &PublicKey {
		&self.get_counterparty_pubkeys().funding_pubkey
	}

	/// Gets the channel's type
	pub fn get_channel_type(&self) -> &ChannelTypeFeatures {
		&self.channel_transaction_parameters.channel_type_features
	}

	/// Returns the height in which our funding transaction was confirmed.
	pub fn get_funding_tx_confirmation_height(&self) -> Option<u32> {
		let conf_height = self.funding_tx_confirmation_height;
		if conf_height > 0 {
			Some(conf_height)
		} else {
			None
		}
	}

	/// Returns the current number of confirmations on the funding transaction.
	pub fn get_funding_tx_confirmations(&self, height: u32) -> u32 {
		if self.funding_tx_confirmation_height == 0 {
			// We either haven't seen any confirmation yet, or observed a reorg.
			return 0;
		}

		height.checked_sub(self.funding_tx_confirmation_height).map_or(0, |c| c + 1)
	}

	/// Gets the channel's `short_channel_id`.
	///
	/// Will return `None` if the funding hasn't been confirmed yet.
	pub fn get_short_channel_id(&self) -> Option<u64> {
		self.short_channel_id
	}

	/// Constructs a `FundingScope` for splicing a channel.
	fn for_splice<SP: SignerProvider>(
		prev_funding: &Self, context: &ChannelContext<SP>, our_funding_contribution: SignedAmount,
		their_funding_contribution: SignedAmount, counterparty_funding_pubkey: PublicKey,
		our_new_holder_keys: ChannelPublicKeys, min_funding_satoshis: u64,
	) -> Result<Self, String> {
		if our_funding_contribution.unsigned_abs() > Amount::MAX_MONEY {
			return Err(format!(
				"Our {} contribution exceeds the total bitcoin supply",
				our_funding_contribution,
			));
		}

		if their_funding_contribution.unsigned_abs() > Amount::MAX_MONEY {
			return Err(format!(
				"Their {} contribution exceeds the total bitcoin supply",
				their_funding_contribution,
			));
		}

		let channel_value_satoshis = prev_funding.get_value_satoshis();
		let value_to_self_satoshis = prev_funding.get_value_to_self_msat() / 1000;
		let value_to_counterparty_satoshis = channel_value_satoshis
			.checked_sub(value_to_self_satoshis)
			.expect("value_to_self is greater than channel value");
		let our_funding_contribution_sat = our_funding_contribution.to_sat();
		let their_funding_contribution_sat = their_funding_contribution.to_sat();

		let post_value_to_self_msat = prev_funding
			.get_value_to_self_msat()
			.checked_add_signed(our_funding_contribution_sat * 1000)
			.ok_or(format!(
				"Our contribution candidate {our_funding_contribution_sat}sat is \
				greater than our total balance in the channel {value_to_self_satoshis}sat"
			))?;

		value_to_counterparty_satoshis.checked_add_signed(their_funding_contribution_sat).ok_or(
			format!(
				"Their contribution candidate {their_funding_contribution_sat}sat is \
				greater than their total balance in the channel {value_to_counterparty_satoshis}sat"
			),
		)?;

		let post_channel_value_sat = prev_funding
			.get_value_satoshis()
			.checked_add_signed(our_funding_contribution.to_sat())
			.and_then(|v| v.checked_add_signed(their_funding_contribution.to_sat()))
			.ok_or(format!(
				"The sum of contributions {our_funding_contribution} and \
				{their_funding_contribution} is greater than the channel's value"
			))?;
		if post_channel_value_sat < MIN_CHANNEL_VALUE_SATOSHIS {
			return Err(format!(
				"Spliced channel value must be at least 1000 satoshis. It would be \
				{post_channel_value_sat}"
			));
		}
		if post_channel_value_sat < min_funding_satoshis
			&& their_funding_contribution.is_negative()
			&& !prev_funding.is_outbound()
		{
			return Err(format!(
				"Spliced channel value {post_channel_value_sat} would be smaller \
				than the configured min_funding_satoshis {min_funding_satoshis}"
			));
		}

		let channel_parameters = &prev_funding.channel_transaction_parameters;
		let mut post_channel_transaction_parameters = ChannelTransactionParameters {
			holder_pubkeys: our_new_holder_keys,
			holder_selected_contest_delay: channel_parameters.holder_selected_contest_delay,
			// The 'outbound' attribute doesn't change, even if the splice initiator is the other node
			is_outbound_from_holder: channel_parameters.is_outbound_from_holder,
			counterparty_parameters: channel_parameters.counterparty_parameters.clone(),
			funding_outpoint: None, // filled later
			splice_parent_funding_txid: prev_funding.get_funding_txid(),
			channel_type_features: channel_parameters.channel_type_features.clone(),
			channel_value_satoshis: post_channel_value_sat,
		};
		post_channel_transaction_parameters
			.counterparty_parameters
			.as_mut()
			.expect("counterparty_parameters should be set")
			.pubkeys
			.funding_pubkey = counterparty_funding_pubkey;

		// New reserve values are based on the new channel value and are v2-specific
		let counterparty_selected_channel_reserve_satoshis = get_v2_channel_reserve_satoshis(
			post_channel_value_sat,
			context.holder_dust_limit_satoshis,
			prev_funding
				.counterparty_selected_channel_reserve_satoshis
				.expect("counterparty reserve is set")
				== 0,
		)
		.map_err(|()| {
			format!(
				"The post-splice channel value {post_channel_value_sat} is smaller \
				than our dust limit {}",
				context.holder_dust_limit_satoshis
			)
		})?;
		let holder_selected_channel_reserve_satoshis = get_v2_channel_reserve_satoshis(
			post_channel_value_sat,
			context.counterparty_dust_limit_satoshis,
			prev_funding.holder_selected_channel_reserve_satoshis == 0,
		)
		.map_err(|()| {
			format!(
				"The post-splice channel value {post_channel_value_sat} is smaller \
				than their dust limit {}",
				context.counterparty_dust_limit_satoshis,
			)
		})?;

		Ok(Self {
			channel_transaction_parameters: post_channel_transaction_parameters,
			value_to_self_msat: post_value_to_self_msat,
			funding_transaction: None,
			counterparty_selected_channel_reserve_satoshis: Some(
				counterparty_selected_channel_reserve_satoshis,
			),
			holder_selected_channel_reserve_satoshis,
			#[cfg(debug_assertions)]
			holder_prev_commitment_tx_balance: {
				let prev = *prev_funding.holder_prev_commitment_tx_balance.lock().unwrap();
				let new_holder_balance_msat =
					prev.0.saturating_add_signed(our_funding_contribution.to_sat() * 1000);
				let new_counterparty_balance_msat =
					prev.1.saturating_add_signed(their_funding_contribution.to_sat() * 1000);
				Mutex::new((new_holder_balance_msat, new_counterparty_balance_msat))
			},
			#[cfg(debug_assertions)]
			counterparty_prev_commitment_tx_balance: {
				let prev = *prev_funding.counterparty_prev_commitment_tx_balance.lock().unwrap();
				let new_holder_balance_msat =
					prev.0.saturating_add_signed(our_funding_contribution.to_sat() * 1000);
				let new_counterparty_balance_msat =
					prev.1.saturating_add_signed(their_funding_contribution.to_sat() * 1000);
				Mutex::new((new_holder_balance_msat, new_counterparty_balance_msat))
			},
			#[cfg(any(test, fuzzing))]
			next_local_fee: Mutex::new(PredictedNextFee::default()),
			#[cfg(any(test, fuzzing))]
			next_remote_fee: Mutex::new(PredictedNextFee::default()),
			funding_tx_confirmation_height: 0,
			funding_tx_confirmed_in: None,
			minimum_depth_override: None,
			short_channel_id: None,
		})
	}

	/// Returns a `SharedOwnedInput` for using this `FundingScope` as the input to a new splice.
	fn to_splice_funding_input(&self) -> SharedOwnedInput {
		let funding_txo = self.get_funding_txo().expect("funding_txo should be set");
		let input = TxIn {
			previous_output: funding_txo.into_bitcoin_outpoint(),
			script_sig: ScriptBuf::new(),
			sequence: Sequence::ENABLE_RBF_NO_LOCKTIME,
			witness: Witness::new(),
		};

		let prev_output = TxOut {
			value: Amount::from_sat(self.get_value_satoshis()),
			script_pubkey: self.get_funding_redeemscript().to_p2wsh(),
		};

		let local_owned = self.value_to_self_msat / 1000;
		let holder_sig_first = self.holder_funding_pubkey().serialize()[..]
			< self.counterparty_funding_pubkey().serialize()[..];

		SharedOwnedInput::new(
			input,
			prev_output,
			local_owned,
			holder_sig_first,
			self.get_funding_redeemscript(),
		)
	}
}

/// Information about pending attempts at funding a channel. This includes funding currently under
/// negotiation and any negotiated attempts waiting enough on-chain confirmations. More than one
/// such attempt indicates use of RBF to increase the chances of confirmation.
#[derive(Debug)]
struct PendingFunding {
	funding_negotiation: Option<FundingNegotiation>,

	/// Our contribution to the funding negotiation round currently in progress, if we are
	/// contributing to it. Set when the round starts, moved into the [`NegotiatedCandidate`]
	/// when negotiation completes, and dropped in
	/// [`FundedChannel::reset_pending_splice_state`] if the round is abandoned.
	///
	/// When the counterparty initiates an RBF and a prior round included our contribution, this
	/// is set to that contribution adjusted to the new feerate (or the RBF is rejected if the
	/// adjustment fails, in which case no round starts). This ensures a splice we contributed to
	/// never loses our contribution in subsequent rounds.
	negotiation_contribution: Option<FundingContribution>,

	/// Funding candidates that have been negotiated but have not reached enough confirmations
	/// by both counterparties to have exchanged `splice_locked` and be promoted.
	negotiated_candidates: Vec<NegotiatedCandidate>,

	/// The funding txid used in the `splice_locked` sent to the counterparty.
	sent_funding_txid: Option<Txid>,

	/// The funding txid used in the `splice_locked` received from the counterparty.
	received_funding_txid: Option<Txid>,

	/// The feerate used in the last successfully negotiated funding transaction.
	/// Used for validating the minimum feerate increase rule on RBF attempts.
	last_funding_feerate_sat_per_1000_weight: Option<u32>,
}

/// A funding candidate that has been negotiated, together with our contribution, if any, to the
/// negotiation round that produced it.
#[derive(Debug)]
struct NegotiatedCandidate {
	funding: FundingScope,

	/// Our contribution to the negotiation round that produced this candidate, or `None` if only
	/// the counterparty contributed. Once a candidate includes our contribution, every later
	/// candidate does as well: RBF rounds carry the contribution forward (possibly adjusted to a
	/// new feerate) rather than dropping it, preserving the splice intention.
	contribution: Option<FundingContribution>,
}

impl_writeable_tlv_based!(NegotiatedCandidate, {
	(1, funding, required),
	(3, contribution, option),
});

#[derive(Debug)]
enum FundingNegotiation {
	AwaitingAck {
		context: FundingNegotiationContext,
		new_holder_funding_key: PublicKey,
	},
	ConstructingTransaction {
		funding: FundingScope,
		funding_feerate_sat_per_1000_weight: u32,
		interactive_tx_constructor: InteractiveTxConstructor,
	},
	AwaitingSignatures {
		funding: FundingScope,
		funding_feerate_sat_per_1000_weight: u32,
		is_initiator: bool,
		/// The initial [`msgs::CommitmentSigned`] message received for the [`FundingScope`] above.
		/// We delay processing this until the user manually approves the splice via
		/// [`Channel::funding_transaction_signed`], as otherwise, there would be a
		/// [`ChannelMonitorUpdateStep::RenegotiatedFunding`] committed that we would need to undo
		/// if they no longer wish to proceed.
		///
		/// Note that this doesn't need to be done with dual-funded channels as there is no
		/// equivalent monitor update for them, and we can just force close the channel.
		///
		/// This field is not persisted as the message should be resent on reconnections.
		initial_commitment_signed_from_counterparty: Option<msgs::CommitmentSigned>,
	},
}

impl_writeable_tlv_based_enum_upgradable!(FundingNegotiation,
	(0, AwaitingSignatures) => {
		(1, funding, required),
		(3, is_initiator, required),
		(5, funding_feerate_sat_per_1000_weight, (default_value, 0)),
		(_unused, initial_commitment_signed_from_counterparty, (static_value, None)),
	},
	unread_variants: AwaitingAck, ConstructingTransaction
);

struct PendingFundingWriteable<'a> {
	pending_funding: &'a PendingFunding,
	reset_funding_negotiation: bool,
}

impl Writeable for PendingFundingWriteable<'_> {
	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
		let funding_negotiation = if self.reset_funding_negotiation {
			None
		} else {
			self.pending_funding.funding_negotiation.as_ref()
		};
		debug_assert!(
			funding_negotiation.is_none()
				|| matches!(
					funding_negotiation,
					Some(FundingNegotiation::AwaitingSignatures { .. })
				)
		);
		// The in-flight round's contribution is only written if its negotiation survives
		// serialization round trips. It goes in an odd TLV that LDK 0.2 skips (0.2 never tracked
		// contributions), so a single in-flight splice we contributed to stays loadable there.
		let negotiation_contribution = funding_negotiation
			.is_some()
			.then(|| self.pending_funding.negotiation_contribution.as_ref())
			.flatten();
		let candidates = &self.pending_funding.negotiated_candidates;
		debug_assert!(
			self.pending_funding.contributions_form_suffix(),
			"contributions must form a suffix of the negotiated candidates",
		);
		// TLV 3 exposes only the first candidate's funding: the single-splice view LDK 0.2
		// understands. The authoritative candidate list -- each funding bundled with its
		// contribution -- goes in the odd TLV 11, which current reads and 0.2 skips. A single
		// non-contributory splice is fully captured by TLV 3 alone, so the bundle is then omitted.
		// When a single splice does carry a contribution, 0.2 skips it (and operates the splice
		// without it), so it need not block 0.2 from loading.
		//
		// The even TLV 14 is the only thing that makes 0.2 refuse, and it's written exactly when
		// there is more than one negotiation round (RBF) -- the one thing 0.2 cannot operate. The
		// odd contribution fields are safe despite being load-bearing for RBF: this gate makes 0.2
		// refuse the whole channel in that case, so no reader ever skips them when they matter.
		let first_funding = Iterable(candidates.iter().take(1).map(|candidate| &candidate.funding));
		let any_contribution = candidates.iter().any(|candidate| candidate.contribution.is_some());
		let negotiated_candidates =
			(candidates.len() > 1 || any_contribution).then(|| Iterable(candidates.iter()));
		let is_rbf = candidates.len() + usize::from(funding_negotiation.is_some()) > 1;
		let rbf_gate = is_rbf.then_some(());
		write_tlv_fields!(writer, {
			(1, funding_negotiation, upgradable_option),
			(3, first_funding, required),
			(5, self.pending_funding.sent_funding_txid, option),
			(7, self.pending_funding.received_funding_txid, option),
			(9, self.pending_funding.last_funding_feerate_sat_per_1000_weight, option),
			(11, negotiated_candidates, option),
			(13, negotiation_contribution, option),
			(14, rbf_gate, option),
		});
		Ok(())
	}
}

impl Readable for PendingFunding {
	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
		let mut funding_negotiation = None;
		let mut legacy_negotiated_candidates: Option<Vec<FundingScope>> = None;
		let mut sent_funding_txid = None;
		let mut received_funding_txid = None;
		let mut last_funding_feerate_sat_per_1000_weight = None;
		let mut negotiated_candidates: Option<Vec<NegotiatedCandidate>> = None;
		let mut negotiation_contribution: Option<FundingContribution> = None;
		let mut rbf_gate: Option<()> = None;

		read_tlv_fields!(reader, {
			(1, funding_negotiation, upgradable_option),
			(3, legacy_negotiated_candidates, optional_vec),
			(5, sent_funding_txid, option),
			(7, received_funding_txid, option),
			(9, last_funding_feerate_sat_per_1000_weight, option),
			(11, negotiated_candidates, optional_vec),
			(13, negotiation_contribution, option),
			(14, rbf_gate, option),
		});

		// TLV 11 (the candidate list, each funding bundled with its contribution) is authoritative
		// when present. It is omitted for a single non-contributory splice (TLV 3 holds its
		// funding) and for data written by LDK 0.2 (which only ever wrote TLV 3 and tracked no
		// contributions); in both cases the candidates carry no contribution.
		let negotiated_candidates = negotiated_candidates.unwrap_or_else(|| {
			legacy_negotiated_candidates
				.unwrap_or_default()
				.into_iter()
				.map(|funding| NegotiatedCandidate { funding, contribution: None })
				.collect()
		});
		// An in-flight contribution is only written alongside a surviving negotiation round, so a
		// contribution without one is invalid.
		if funding_negotiation.is_none() && negotiation_contribution.is_some() {
			return Err(DecodeError::InvalidValue);
		}
		// TLV 14 (the RBF gate) is written exactly when there is more than one negotiation round, so
		// pre-RBF readers (LDK 0.2) refuse an RBF they cannot operate. Current reconstructs RBF state
		// from the candidate list, but a gate inconsistent with that state is invalid.
		let is_rbf = negotiated_candidates.len() + usize::from(funding_negotiation.is_some()) > 1;
		if rbf_gate.is_some() != is_rbf {
			return Err(DecodeError::InvalidValue);
		}

		Ok(PendingFunding {
			funding_negotiation,
			negotiation_contribution,
			negotiated_candidates,
			sent_funding_txid,
			received_funding_txid,
			last_funding_feerate_sat_per_1000_weight,
		})
	}
}

impl FundingNegotiation {
	fn as_funding(&self) -> Option<&FundingScope> {
		match self {
			FundingNegotiation::AwaitingAck { .. } => None,
			FundingNegotiation::ConstructingTransaction { funding, .. } => Some(funding),
			FundingNegotiation::AwaitingSignatures { funding, .. } => Some(funding),
		}
	}

	fn funding_feerate_sat_per_1000_weight(&self) -> u32 {
		match self {
			FundingNegotiation::AwaitingAck { context, .. } => {
				context.funding_feerate_sat_per_1000_weight
			},
			FundingNegotiation::ConstructingTransaction {
				funding_feerate_sat_per_1000_weight,
				..
			} => *funding_feerate_sat_per_1000_weight,
			FundingNegotiation::AwaitingSignatures {
				funding_feerate_sat_per_1000_weight, ..
			} => *funding_feerate_sat_per_1000_weight,
		}
	}

	fn is_initiator(&self) -> bool {
		match self {
			FundingNegotiation::AwaitingAck { context, .. } => context.is_initiator,
			FundingNegotiation::ConstructingTransaction { interactive_tx_constructor, .. } => {
				interactive_tx_constructor.is_initiator()
			},
			FundingNegotiation::AwaitingSignatures { is_initiator, .. } => *is_initiator,
		}
	}
	fn for_initiator<SP: SignerProvider, ES: EntropySource>(
		funding: FundingScope, context: &ChannelContext<SP>,
		funding_negotiation_context: FundingNegotiationContext, entropy_source: &ES,
		holder_node_id: &PublicKey,
	) -> (FundingNegotiation, Option<InteractiveTxMessageSend>) {
		let funding_feerate_sat_per_1000_weight =
			funding_negotiation_context.funding_feerate_sat_per_1000_weight;
		let (interactive_tx_constructor, tx_msg_opt) = funding_negotiation_context
			.into_interactive_tx_constructor(
				context,
				&funding,
				entropy_source,
				holder_node_id.clone(),
			);
		debug_assert!(tx_msg_opt.is_some());

		(
			FundingNegotiation::ConstructingTransaction {
				funding,
				funding_feerate_sat_per_1000_weight,
				interactive_tx_constructor,
			},
			tx_msg_opt,
		)
	}

	fn for_acceptor<SP: SignerProvider, ES: EntropySource>(
		funding: FundingScope, context: &ChannelContext<SP>, entropy_source: &ES,
		holder_node_id: &PublicKey, our_funding_contribution: SignedAmount,
		prev_funding_input: SharedOwnedInput, locktime: u32, feerate_sat_per_1000_weight: u32,
		our_funding_inputs: Vec<ConfirmedUtxo>, our_funding_outputs: Vec<TxOut>,
	) -> FundingNegotiation {
		let funding_negotiation_context = FundingNegotiationContext {
			is_initiator: false,
			our_funding_contribution,
			funding_tx_locktime: LockTime::from_consensus(locktime),
			funding_feerate_sat_per_1000_weight: feerate_sat_per_1000_weight,
			shared_funding_input: Some(prev_funding_input),
			our_funding_inputs,
			our_funding_outputs,
		};

		let (interactive_tx_constructor, first_message) = funding_negotiation_context
			.into_interactive_tx_constructor(
				context,
				&funding,
				entropy_source,
				holder_node_id.clone(),
			);
		debug_assert!(first_message.is_none());

		FundingNegotiation::ConstructingTransaction {
			funding,
			funding_feerate_sat_per_1000_weight: feerate_sat_per_1000_weight,
			interactive_tx_constructor,
		}
	}
}

impl PendingFunding {
	fn has_confirmed_candidate(&self) -> bool {
		self.negotiated_candidates
			.iter()
			.any(|candidate| candidate.funding.funding_tx_confirmation_height != 0)
	}

	/// Whether our contributions form a suffix of the negotiated candidates: once a round includes
	/// our contribution, every later round carries it forward (so the splice intention is never
	/// lost).
	fn contributions_form_suffix(&self) -> bool {
		self.negotiated_candidates
			.iter()
			.skip_while(|candidate| candidate.contribution.is_none())
			.all(|candidate| candidate.contribution.is_some())
	}

	fn awaiting_ack_context(
		&self, msg_name: &str,
	) -> Result<(&FundingNegotiationContext, &PublicKey), ChannelError> {
		match &self.funding_negotiation {
			Some(FundingNegotiation::AwaitingAck { context, new_holder_funding_key }) => {
				Ok((context, new_holder_funding_key))
			},
			Some(FundingNegotiation::ConstructingTransaction { .. })
			| Some(FundingNegotiation::AwaitingSignatures { .. }) => Err(ChannelError::WarnAndDisconnect(
				format!("Got unexpected {}; funding negotiation already in progress", msg_name,),
			)),
			None => Err(ChannelError::Ignore(format!(
				"Got unexpected {}; no funding negotiation in progress",
				msg_name,
			))),
		}
	}

	fn take_awaiting_ack_context(
		&mut self, msg_name: &str,
	) -> Result<FundingNegotiationContext, ChannelError> {
		match self.funding_negotiation.take() {
			Some(FundingNegotiation::AwaitingAck { context, .. }) => Ok(context),
			Some(other) => {
				self.funding_negotiation = Some(other);
				Err(ChannelError::WarnAndDisconnect(format!(
					"Got unexpected {}; funding negotiation already in progress",
					msg_name,
				)))
			},
			None => Err(ChannelError::Ignore(format!(
				"Got unexpected {}; no funding negotiation in progress",
				msg_name,
			))),
		}
	}

	/// Returns the minimum feerate for RBF attempts given a previous feerate.
	///
	/// The spec (tx_init_rbf) requires the new feerate to be >= the maximum of 25/24 of the
	/// previous feerate and the previous feerate + 25 sat/kwu. The flat +25 sat/kwu increment
	/// ensures BIP125's relay requirement of an absolute fee increase is satisfied at low feerates
	/// where the multiplicative 25/24 rule alone would be insufficient.
	fn min_rbf_feerate_above(prev_feerate: u32) -> FeeRate {
		let flat_increment = (prev_feerate as u64).saturating_add(25);
		let spec_increment = (prev_feerate as u64) * 25 / 24;
		FeeRate::from_sat_per_kwu(cmp::max(flat_increment, spec_increment))
	}

	/// The minimum feerate a new contribution must pay to replace the pending splice via RBF,
	/// derived from the most recent round's feerate:
	/// - `last_funding_feerate_sat_per_1000_weight`: from a completed but unlocked negotiation
	/// - the `funding_negotiation` feerate: from an in-progress negotiation
	///
	/// Returns `None` when neither feerate is known. The feerate is only persisted by LDK 0.3+,
	/// so its absence means the splice was last written by an older version (negotiated there, or
	/// round-tripped 0.3 -> 0.2 -> 0.3), in which case the pending splice cannot be RBF'd.
	fn min_rbf_feerate(&self) -> Option<FeeRate> {
		self.last_funding_feerate_sat_per_1000_weight
			.or_else(|| {
				self.funding_negotiation.as_ref().map(|n| n.funding_feerate_sat_per_1000_weight())
			})
			.map(Self::min_rbf_feerate_above)
	}

	/// After several RBF attempts, checks that the feerate is high enough to confirm. Returns
	/// `true` if the feerate is sufficient or the threshold hasn't been reached.
	///
	/// The spec requires: "MUST set a high enough feerate to ensure quick confirmation."
	fn is_rbf_feerate_sufficient<F: FeeEstimator>(
		&self, feerate_sat_per_kw: u32, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> bool {
		const MAX_LOW_FEERATE_RBF_ATTEMPTS: usize = 10;
		if self.negotiated_candidates.len() <= MAX_LOW_FEERATE_RBF_ATTEMPTS {
			return true;
		}
		let min_feerate =
			fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
		feerate_sat_per_kw >= min_feerate
	}

	/// The inputs and output scripts committed to this splice's live attempts: the negotiated
	/// candidates and any contribution of ours in the round still under negotiation. Every part of
	/// a candidate's transaction counts when it stores no contribution of ours.
	fn committed_funding_parts(&self) -> (Vec<bitcoin::OutPoint>, Vec<&bitcoin::Script>) {
		let mut inputs = Vec::new();
		let mut output_scripts = Vec::new();
		for candidate in &self.negotiated_candidates {
			match candidate.contribution.as_ref() {
				Some(contribution) => {
					inputs.extend(contribution.contributed_inputs());
					output_scripts.extend(contribution.contributed_outputs());
				},
				None => {
					// A candidate stores no contribution of ours when only the counterparty
					// contributed, but also when it was read from 0.2 data, which did not record
					// contributions. Every part of its transaction counts to cover the latter. Once
					// upgrading from 0.2 is no longer supported, only the stored contributions need
					// to be consulted.
					let transaction = candidate
						.funding
						.funding_transaction
						.as_ref()
						.expect("negotiated candidate must have a funding transaction");
					inputs.extend(transaction.input.iter().map(|txin| txin.previous_output));
					output_scripts.extend(
						transaction.output.iter().map(|txout| txout.script_pubkey.as_script()),
					);
				},
			}
		}
		if let Some(contribution) = self.negotiation_contribution.as_ref() {
			inputs.extend(contribution.contributed_inputs());
			output_scripts.extend(contribution.contributed_outputs());
		}
		(inputs, output_scripts)
	}

	/// Whether `contribution` can wait for the pending candidate to lock and then start a fresh
	/// splice. It must not reuse anything committed to the attempts that may confirm first.
	fn can_queue_contribution_for_fresh_splice(&self, contribution: &FundingContribution) -> bool {
		let (committed_inputs, committed_output_scripts) = self.committed_funding_parts();
		!contribution.contributed_inputs().any(|input| committed_inputs.contains(&input))
			&& !contribution
				.contributed_outputs()
				.any(|output| committed_output_scripts.contains(&output))
	}

	/// Our most recent contribution across rounds, including any round still under negotiation.
	fn latest_contribution(&self) -> Option<&FundingContribution> {
		self.negotiation_contribution.as_ref().or_else(|| {
			self.negotiated_candidates.last().and_then(|candidate| candidate.contribution.as_ref())
		})
	}

	fn to_details<SP: SignerProvider>(
		&self, context: &ChannelContext<SP>, best_block_height: u32,
	) -> SpliceDetails {
		let mut candidates: Vec<SpliceCandidateDetails> = self
			.negotiated_candidates
			.iter()
			.map(|candidate| SpliceCandidateDetails {
				contribution: candidate.contribution.clone(),
				status: SpliceCandidateStatus::Negotiated {
					txid: candidate
						.funding
						.get_funding_txid()
						.expect("negotiated candidates should have a funding txid"),
					new_channel_value_satoshis: candidate.funding.get_value_satoshis(),
				},
			})
			.collect();

		// The round currently under negotiation, if any, follows the negotiated candidates.
		if let Some(funding_negotiation) = self.funding_negotiation.as_ref() {
			let is_initiator = funding_negotiation.is_initiator();
			let funding_feerate_sat_per_1000_weight =
				funding_negotiation.funding_feerate_sat_per_1000_weight();
			let status = match funding_negotiation {
				FundingNegotiation::AwaitingAck { .. } => SpliceCandidateStatus::AwaitingAck {
					is_initiator,
					funding_feerate_sat_per_1000_weight,
				},
				FundingNegotiation::ConstructingTransaction { funding, .. } => {
					SpliceCandidateStatus::ConstructingTransaction {
						is_initiator,
						funding_feerate_sat_per_1000_weight,
						new_channel_value_satoshis: funding.get_value_satoshis(),
					}
				},
				FundingNegotiation::AwaitingSignatures { funding, .. } => {
					SpliceCandidateStatus::AwaitingSignatures {
						is_initiator,
						funding_feerate_sat_per_1000_weight,
						new_channel_value_satoshis: funding.get_value_satoshis(),
						txid: funding
							.get_funding_txid()
							.expect("a splice awaiting signatures should have a funding txid"),
					}
				},
			};
			candidates.push(SpliceCandidateDetails {
				contribution: self.negotiation_contribution.clone(),
				status,
			});
		}
		// At most one candidate can confirm, as they all double-spend the same input. A zero-conf
		// splice is locked (we send `splice_locked`) before it has any confirmations, so also report
		// a candidate we have locked even at zero confirmations.
		let confirmed_candidate = self.negotiated_candidates.iter().find_map(|candidate| {
			let confirmations = candidate.funding.get_funding_tx_confirmations(best_block_height);
			let txid = candidate
				.funding
				.get_funding_txid()
				.expect("negotiated candidates should have a funding txid");
			// The `splice_locked` we sent always refers to the confirmed candidate, as it is
			// cleared if that candidate is ever unconfirmed by a reorg.
			let splice_locked_sent = self.sent_funding_txid == Some(txid);
			if confirmations == 0 && !splice_locked_sent {
				return None;
			}
			Some(ConfirmedSpliceCandidate {
				txid,
				confirmations,
				confirmations_required: context
					.minimum_depth(&candidate.funding)
					.expect("set for a ready channel"),
				splice_locked_sent,
			})
		});
		SpliceDetails {
			candidates,
			confirmed_candidate,
			received_splice_locked_txid: self.received_funding_txid,
		}
	}

	fn check_get_splice_locked<SP: SignerProvider>(
		&mut self, context: &ChannelContext<SP>, confirmed_funding_index: usize, height: u32,
	) -> Option<msgs::SpliceLocked> {
		debug_assert!(confirmed_funding_index < self.negotiated_candidates.len());

		// While quiescent, defer locking any candidate. We may be quiescent due to an ongoing
		// splice RBF negotiation that is mid-signing. Once its `tx_signatures` is exchanged and
		// quiescence terminates, our `splice_locked` is sent on a timer tick.
		if context.channel_state.is_quiescent() {
			return None;
		}

		let funding = &self.negotiated_candidates[confirmed_funding_index].funding;
		if !context.check_funding_meets_minimum_depth(funding, height) {
			return None;
		}

		let confirmed_funding_txid = match funding.get_funding_txid() {
			Some(funding_txid) => funding_txid,
			None => {
				debug_assert!(false);
				return None;
			},
		};

		match self.sent_funding_txid {
			Some(sent_funding_txid) if confirmed_funding_txid == sent_funding_txid => None,
			_ => {
				let splice_locked = msgs::SpliceLocked {
					channel_id: context.channel_id(),
					splice_txid: confirmed_funding_txid,
				};
				self.sent_funding_txid = Some(splice_locked.splice_txid);
				Some(splice_locked)
			},
		}
	}
}

#[derive(Debug)]
pub(crate) enum QuiescentAction {
	Splice {
		contribution: FundingContribution,
		locktime: LockTime,
	},
	#[cfg(any(test, fuzzing, feature = "_test_utils"))]
	DoNothing,
}

pub(super) enum QuiescentError {
	DoNothing,
	DiscardFunding { inputs: Vec<bitcoin::OutPoint>, outputs: Vec<bitcoin::ScriptBuf> },
	FailSplice(SpliceFundingFailed, NegotiationFailureReason),
}

pub(crate) enum StfuResponse {
	Stfu(msgs::Stfu),
	SpliceInit(msgs::SpliceInit),
	TxInitRbf(msgs::TxInitRbf),
}

/// Wrapper around a [`Transaction`] useful for caching the result of [`Transaction::compute_txid`].
struct ConfirmedTransaction<'a> {
	tx: &'a Transaction,
	txid: Option<Txid>,
}

impl<'a> ConfirmedTransaction<'a> {
	/// Returns the underlying [`Transaction`].
	pub fn tx(&self) -> &'a Transaction {
		self.tx
	}

	/// Returns the [`Txid`], computing and caching it if necessary.
	pub fn txid(&mut self) -> Txid {
		*self.txid.get_or_insert_with(|| self.tx.compute_txid())
	}
}

impl<'a> From<&'a Transaction> for ConfirmedTransaction<'a> {
	fn from(tx: &'a Transaction) -> Self {
		ConfirmedTransaction { tx, txid: None }
	}
}

/// Contains everything about the channel including state, and various flags.
pub(super) struct ChannelContext<SP: SignerProvider> {
	config: LegacyChannelConfig,

	// Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
	// constructed using it. The second element in the tuple corresponds to the number of ticks that
	// have elapsed since the update occurred.
	prev_config: Option<(ChannelConfig, usize)>,

	inbound_handshake_limits_override: Option<ChannelHandshakeLimits>,

	user_id: u128,

	/// The current channel ID.
	channel_id: ChannelId,
	/// The temporary channel ID used during channel setup. Value kept even after transitioning to a final channel ID.
	/// Will be `None` for channels created prior to 0.0.115.
	temporary_channel_id: Option<ChannelId>,
	channel_state: ChannelState,

	// When we reach max(6 blocks, minimum_depth), we need to send an AnnouncementSigs message to
	// our peer. However, we want to make sure they received it, or else rebroadcast it when we
	// next connect.
	// We do so here, see `AnnouncementSigsSent` for more details on the state(s).
	// Note that a number of our tests were written prior to the behavior here which retransmits
	// AnnouncementSignatures until after an RAA completes, so the behavior is short-circuited in
	// many tests.
	#[cfg(any(test, feature = "_test_utils"))]
	pub(crate) announcement_sigs_state: AnnouncementSigsState,
	#[cfg(not(any(test, feature = "_test_utils")))]
	announcement_sigs_state: AnnouncementSigsState,

	secp_ctx: Secp256k1<secp256k1::All>,

	latest_monitor_update_id: u64,

	holder_signer: SP::EcdsaSigner,
	shutdown_scriptpubkey: Option<ShutdownScript>,
	destination_script: ScriptBuf,

	// Our commitment numbers start at 2^48-1 and count down, whereas the ones used in transaction
	// generation start at 0 and count up...this simplifies some parts of implementation at the
	// cost of others, but should really just be changed.
	counterparty_next_commitment_transaction_number: u64,
	pending_inbound_htlcs: Vec<InboundHTLCOutput>,
	pending_outbound_htlcs: Vec<OutboundHTLCOutput>,
	holding_cell_htlc_updates: Vec<HTLCUpdateAwaitingACK>,

	/// When resending CS/RAA messages on channel monitor restoration or on reconnect, we always
	/// need to ensure we resend them in the order we originally generated them. Note that because
	/// there can only ever be one in-flight CS and/or one in-flight RAA at any time, it is
	/// sufficient to simply set this to the opposite of any message we are generating as we
	/// generate it. ie when we generate a CS, we set this to RAAFirst as, if there is a pending
	/// in-flight RAA to resend, it will have been the first thing we generated, and thus we should
	/// send it first.
	resend_order: RAACommitmentOrder,

	monitor_pending_tx_signatures: bool,
	monitor_pending_channel_ready: bool,
	monitor_pending_revoke_and_ack: bool,
	monitor_pending_commitment_signed: bool,

	// TODO: If a channel is drop'd, we don't know whether the `ChannelMonitor` is ultimately
	// responsible for some of the HTLCs here or not - we don't know whether the update in question
	// completed or not. Other than `monitor_pending_failures`, which are handed to the
	// `ChannelMonitor` when force-closing, we currently ignore these fields entirely when
	// force-closing a channel, but need to handle this somehow or we run the risk of losing HTLCs!
	monitor_pending_forwards: Vec<(PendingHTLCInfo, u64)>,
	monitor_pending_failures: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
	monitor_pending_finalized_fulfills: Vec<(HTLCSource, Option<AttributionData>)>,
	monitor_pending_update_adds: Vec<msgs::UpdateAddHTLC>,

	/// If we went to send a revoke_and_ack but our signer was unable to give us a signature,
	/// we should retry at some point in the future when the signer indicates it may have a
	/// signature for us.
	///
	/// This may also be used to make sure we send a `revoke_and_ack` after a `commitment_signed`
	/// if we need to maintain ordering of messages, but are pending the signer on a previous
	/// message.
	signer_pending_revoke_and_ack: bool,
	/// If we went to send a commitment update (ie some messages then [`msgs::CommitmentSigned`])
	/// but our signer (initially) refused to give us a signature, we should retry at some point in
	/// the future when the signer indicates it may have a signature for us.
	///
	/// This flag is set in such a case. Note that we don't need to persist this as we'll end up
	/// setting it again as a side-effect of [`FundedChannel::channel_reestablish`].
	signer_pending_commitment_update: bool,
	/// Similar to [`Self::signer_pending_commitment_update`] but we're waiting to send either a
	/// [`msgs::FundingCreated`] for an outbound V1 channel, [`msgs::FundingSigned`] for an inbound
	/// V1 channel, or [`msgs::CommitmentSigned`] for a V2 channel (dual-funded) or a funded channel
	/// with a pending splice.
	signer_pending_funding: bool,
	/// If we attempted to sign a cooperative close transaction but the signer wasn't ready, then this
	/// will be set to `true`.
	signer_pending_closing: bool,
	/// Similar to [`Self::signer_pending_commitment_update`] but we're waiting to send a
	/// [`msgs::ChannelReady`].
	signer_pending_channel_ready: bool,
	// Upon receiving a [`msgs::ChannelReestablish`] message with a `next_remote_commitment_number`
	// indicating that our state may be stale, we set this to the received last-revoked commitment
	// number and secret to perform the verification when the signer is ready.
	signer_pending_stale_state_verification: Option<(u64, SecretKey)>,

	// pending_update_fee is filled when sending and receiving update_fee.
	//
	// Because it follows the same commitment flow as HTLCs, `FeeUpdateState` is either `Outbound`
	// or matches a subset of the `InboundHTLCOutput` variants. It is then updated/used when
	// generating new commitment transactions with exactly the same criteria as inbound/outbound
	// HTLCs with similar state.
	pending_update_fee: Option<(u32, FeeUpdateState)>,
	// If a `send_update_fee()` call is made with ChannelState::AwaitingRemoteRevoke set, we place
	// it here instead of `pending_update_fee` in the same way as we place outbound HTLC updates in
	// `holding_cell_htlc_updates` instead of `pending_outbound_htlcs`. It is released into
	// `pending_update_fee` with the same criteria as outbound HTLC updates but can be updated by
	// further `send_update_fee` calls, dropping the previous holding cell update entirely.
	#[cfg(any(test, feature = "_test_utils"))]
	pub(super) holding_cell_update_fee: Option<u32>,
	#[cfg(not(any(test, feature = "_test_utils")))]
	holding_cell_update_fee: Option<u32>,
	next_holder_htlc_id: u64,
	pub(super) next_counterparty_htlc_id: u64,
	pub(super) feerate_per_kw: u32,

	/// The timestamp set on our latest `channel_update` message for this channel. It is updated
	/// when the channel is updated in ways which may impact the `channel_update` message or when a
	/// new block is received, ensuring it's always at least moderately close to the current real
	/// time.
	update_time_counter: u32,

	// (fee_sats, skip_remote_output, fee_range, holder_sig)
	last_sent_closing_fee: Option<(u64, bool, ClosingSignedFeeRange, Option<Signature>)>,
	last_received_closing_sig: Option<Signature>,
	target_closing_feerate_sats_per_kw: Option<u32>,

	/// If our counterparty sent us a closing_signed while we were waiting for a `ChannelMonitor`
	/// update, we need to delay processing it until later. We do that here by simply storing the
	/// closing_signed message and handling it in `maybe_propose_closing_signed`.
	pending_counterparty_closing_signed: Option<msgs::ClosingSigned>,

	/// The minimum and maximum absolute fee, in satoshis, we are willing to place on the closing
	/// transaction. These are set once we reach `closing_negotiation_ready`.
	#[cfg(any(test, feature = "_test_utils"))]
	pub(crate) closing_fee_limits: Option<(u64, u64)>,
	#[cfg(not(any(test, feature = "_test_utils")))]
	closing_fee_limits: Option<(u64, u64)>,

	/// If we remove an HTLC (or fee update), commit, and receive our counterparty's
	/// `revoke_and_ack`, we remove all knowledge of said HTLC (or fee update). However, the latest
	/// local commitment transaction that we can broadcast still contains the HTLC (or old fee)
	/// until we receive a further `commitment_signed`. Thus we are not eligible for initiating the
	/// `closing_signed` negotiation if we're expecting a counterparty `commitment_signed`.
	///
	/// To ensure we don't send a `closing_signed` too early, we track this state here, waiting
	/// until we see a `commitment_signed` before doing so.
	///
	/// We don't bother to persist this - we anticipate this state won't last longer than a few
	/// milliseconds, so any accidental force-closes here should be exceedingly rare.
	expecting_peer_commitment_signed: bool,

	/// Either the height at which this channel was created or the height at which it was last
	/// serialized if it was serialized by versions prior to 0.0.103.
	/// We use this to close if funding is never broadcasted.
	pub(super) channel_creation_height: u32,

	#[cfg(any(test, feature = "_test_utils"))]
	pub(crate) counterparty_dust_limit_satoshis: u64,
	#[cfg(not(any(test, feature = "_test_utils")))]
	counterparty_dust_limit_satoshis: u64,

	#[cfg(any(test, feature = "_test_utils"))]
	pub(crate) holder_dust_limit_satoshis: u64,
	#[cfg(not(any(test, feature = "_test_utils")))]
	holder_dust_limit_satoshis: u64,

	#[cfg(any(test, feature = "_test_utils"))]
	pub(crate) counterparty_max_htlc_value_in_flight_msat: u64,
	#[cfg(not(any(test, feature = "_test_utils")))]
	counterparty_max_htlc_value_in_flight_msat: u64,

	#[cfg(any(test, feature = "_test_utils"))]
	pub(super) holder_max_htlc_value_in_flight_msat: u64,
	#[cfg(not(any(test, feature = "_test_utils")))]
	holder_max_htlc_value_in_flight_msat: u64,

	counterparty_htlc_minimum_msat: u64,
	holder_htlc_minimum_msat: u64,
	#[cfg(any(test, feature = "_test_utils"))]
	pub counterparty_max_accepted_htlcs: u16,
	#[cfg(not(any(test, feature = "_test_utils")))]
	counterparty_max_accepted_htlcs: u16,
	holder_max_accepted_htlcs: u16,
	minimum_depth: Option<u32>,

	counterparty_forwarding_info: Option<CounterpartyForwardingInfo>,

	/// This flag indicates that it is the user's responsibility to validated and broadcast the
	/// funding transaction.
	is_manual_broadcast: bool,
	is_batch_funding: Option<()>,

	counterparty_next_commitment_point: Option<PublicKey>,
	counterparty_current_commitment_point: Option<PublicKey>,
	counterparty_node_id: PublicKey,

	counterparty_shutdown_scriptpubkey: Option<ScriptBuf>,

	commitment_secrets: CounterpartyCommitmentSecrets,

	channel_update_status: ChannelUpdateStatus,
	/// Once we reach `closing_negotiation_ready`, we set this, indicating if closing_signed does
	/// not complete within a single timer tick (one minute), we should force-close the channel.
	/// This prevents us from keeping unusable channels around forever if our counterparty wishes
	/// to DoS us.
	/// Note that this field is reset to false on deserialization to give us a chance to connect to
	/// our peer and start the closing_signed negotiation fresh.
	closing_signed_in_flight: bool,

	/// Our counterparty's channel_announcement signatures provided in announcement_signatures.
	/// This can be used to rebroadcast the channel_announcement message later.
	announcement_sigs: Option<(Signature, Signature)>,

	/// lnd has a long-standing bug where, upon reconnection, if the channel is not yet confirmed
	/// they will not send a channel_reestablish until the channel locks in. Then, they will send a
	/// channel_ready *before* sending the channel_reestablish (which is clearly a violation of
	/// the BOLT specs). We copy c-lightning's workaround here and simply store the channel_ready
	/// message until we receive a channel_reestablish.
	///
	/// See-also <https://github.com/lightningnetwork/lnd/issues/4006>
	pub workaround_lnd_bug_4006: Option<msgs::ChannelReady>,

	/// The `my_current_funding_locked` txid included in our `channel_reestablish` for the current
	/// reconnect, if any. We track this as we cannot tell what was included after we've already
	/// sent it, as it's possible it was unconfirmed at the time we sent it, but confirmed shortly
	/// after.
	funding_locked_txid_sent_in_reestablish: Option<Txid>,

	/// An option set when we wish to track how many ticks have elapsed while waiting for a response
	/// from our counterparty after entering specific states. If the peer has yet to respond after
	/// reaching `DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`, a reconnection should be attempted to
	/// try to unblock the state machine.
	///
	/// This behavior was initially motivated by a lnd bug in which we don't receive a message we
	/// expect to in a timely manner, which may lead to channels becoming unusable and/or
	/// force-closed. An example of such can be found at
	/// <https://github.com/lightningnetwork/lnd/issues/7682>.
	sent_message_awaiting_response: Option<usize>,

	// Our counterparty can offer us SCID aliases which they will map to this channel when routing
	// outbound payments. These can be used in invoice route hints to avoid explicitly revealing
	// the channel's funding UTXO.
	//
	// We also use this when sending our peer a channel_update that isn't to be broadcasted
	// publicly - allowing them to re-use their map of SCID -> channel for channel_update ->
	// associated channel mapping.
	//
	// We only bother storing the most recent SCID alias at any time, though our counterparty has
	// to store all of them.
	latest_inbound_scid_alias: Option<u64>,

	// We always offer our counterparty a static SCID alias, which we recognize as for this channel
	// if we see it in HTLC forwarding instructions. We don't bother rotating the alias given we
	// don't currently support node id aliases and eventually privacy should be provided with
	// blinded paths instead of simple scid+node_id aliases.
	outbound_scid_alias: u64,

	/// Short channel ids used by any prior FundingScope. These are maintained such that
	/// ChannelManager can look up the channel for any pending HTLCs.
	historical_scids: Vec<u64>,

	// We track whether we already emitted a `ChannelPending` event.
	channel_pending_event_emitted: bool,

	// We track whether we already emitted a `FundingTxBroadcastSafe` event.
	funding_tx_broadcast_safe_event_emitted: bool,

	// We track whether we already emitted an initial `ChannelReady` event.
	initial_channel_ready_event_emitted: bool,

	/// Some if we initiated to shut down the channel.
	local_initiated_shutdown: Option<()>,

	/// The unique identifier used to re-derive the private key material for the channel through
	/// [`SignerProvider::derive_channel_signer`].
	#[cfg(not(any(test, feature = "_test_utils")))]
	channel_keys_id: [u8; 32],
	#[cfg(any(test, feature = "_test_utils"))]
	pub channel_keys_id: [u8; 32],

	/// If we can't release a [`ChannelMonitorUpdate`] until some external action completes, we
	/// store it here and only release it to the `ChannelManager` once it asks for it.
	blocked_monitor_updates: Vec<PendingChannelMonitorUpdate>,

	/// The signing session for the current interactive tx construction, if any.
	///
	/// This is populated when the interactive tx construction phase completes (i.e., upon receiving
	/// a consecutive `tx_complete`) and the channel enters the signing phase.
	///
	/// This field is cleared once our counterparty sends a `channel_ready` or upon splice funding
	/// promotion.
	pub interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
}

#[cfg(test)]
impl<SP: SignerProvider> fmt::Debug for ChannelContext<SP> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		f.debug_struct("ChannelContext").finish()
	}
}

/// A channel struct implementing this trait can receive an initial counterparty commitment
/// transaction signature.
trait InitialRemoteCommitmentReceiver<SP: SignerProvider> {
	fn context(&self) -> &ChannelContext<SP>;

	fn context_mut(&mut self) -> &mut ChannelContext<SP>;

	fn funding(&self) -> &FundingScope;

	fn funding_mut(&mut self) -> &mut FundingScope;

	fn received_msg(&self) -> &'static str;

	#[rustfmt::skip]
	fn check_counterparty_commitment_signature<L: Logger>(
		&self, sig: &Signature, holder_commitment_point: &HolderCommitmentPoint, logger: &L
	) -> Result<CommitmentTransaction, ChannelError> {
		let funding_script = self.funding().get_funding_redeemscript();

		let commitment_data = self.context().build_commitment_transaction(self.funding(),
			holder_commitment_point.next_transaction_number(), &holder_commitment_point.next_point(),
			true, false, logger);
		let initial_commitment_tx = commitment_data.tx;
		let trusted_tx = initial_commitment_tx.trust();
		let initial_commitment_bitcoin_tx = trusted_tx.built_transaction();
		let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.funding().get_value_satoshis());
		// They sign the holder commitment transaction...
		log_trace!(logger, "Checking {} tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} for channel {}.",
			self.received_msg(), log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.funding().counterparty_funding_pubkey().serialize()),
			encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]),
			encode::serialize_hex(&funding_script), &self.context().channel_id());
		secp_check!(self.context().secp_ctx.verify_ecdsa(&sighash, sig, self.funding().counterparty_funding_pubkey()), format!("Invalid {} signature from peer", self.received_msg()));

		Ok(initial_commitment_tx)
	}

	#[rustfmt::skip]
	fn initial_commitment_signed<L: Logger>(
		&mut self, channel_id: ChannelId, counterparty_signature: Signature, holder_commitment_point: &mut HolderCommitmentPoint,
		best_block: BlockLocator, signer_provider: &SP, logger: &L,
	) -> Result<(ChannelMonitor<SP::EcdsaSigner>, CommitmentTransaction), ChannelError> {
		let initial_commitment_tx = match self.check_counterparty_commitment_signature(&counterparty_signature, holder_commitment_point, logger) {
			Ok(res) => res,
			Err(ChannelError::Close(e)) => {
				// TODO(dual_funding): Update for V2 established channels.
				if !self.funding().is_outbound() {
					self.funding_mut().channel_transaction_parameters.funding_outpoint = None;
				}
				return Err(ChannelError::Close(e));
			},
			Err(e) => {
				// The only error we know how to handle is ChannelError::Close, so we fall over here
				// to make sure we don't continue with an inconsistent state.
				panic!("unexpected error type from check_counterparty_commitment_signature {:?}", e);
			}
		};
		let context = self.context();
		let commitment_data = context.build_commitment_transaction(self.funding(),
			context.counterparty_next_commitment_transaction_number,
			&context.counterparty_next_commitment_point.unwrap(), false, false, logger);
		let counterparty_initial_commitment_tx = commitment_data.tx;
		let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
		let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();

		log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
			&context.channel_id(), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));

		let holder_commitment_tx = HolderCommitmentTransaction::new(
			initial_commitment_tx,
			counterparty_signature,
			Vec::new(),
			&self.funding().get_holder_pubkeys().funding_pubkey,
			&self.funding().counterparty_funding_pubkey()
		);

		if context.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new()).is_err() {
			return Err(ChannelError::close("Failed to validate our commitment".to_owned()));
		}

		// Now that we're past error-generating stuff, update our local state:

		let is_v2_established = self.is_v2_established();
		let context = self.context_mut();
		context.channel_id = channel_id;

		assert!(!context.channel_state.is_monitor_update_in_progress()); // We have not had any monitor(s) yet to fail update!
		if !is_v2_established {
			if context.is_batch_funding() {
				context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH);
			} else {
				context.channel_state = ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
			}
		}
		if holder_commitment_point.advance(&context.holder_signer, &context.secp_ctx, logger).is_err() {
			// We only fail to advance our commitment point/number if we're currently
			// waiting for our signer to unblock and provide a commitment point.
			// We cannot send accept_channel/open_channel before this has occurred, so if we
			// err here by the time we receive funding_created/funding_signed, something has gone wrong.
			debug_assert!(false, "We should be ready to advance our commitment point by the time we receive {}", self.received_msg());
			return Err(ChannelError::close("Failed to advance holder commitment point".to_owned()));
		}

		let context = self.context();
		let funding = self.funding();
		let obscure_factor = get_commitment_transaction_number_obscure_factor(&funding.get_holder_pubkeys().payment_point, &funding.get_counterparty_pubkeys().payment_point, funding.is_outbound());
		let shutdown_script = context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
		let monitor_signer = signer_provider.derive_channel_signer(context.channel_keys_id);
		// TODO(RBF): When implementing RBF, the funding_txo passed here must only update
		// ChannelMonitorImp::first_confirmed_funding_txo during channel establishment, not splicing
		let channel_monitor = ChannelMonitor::new(
			context.secp_ctx.clone(), monitor_signer, shutdown_script,
			funding.get_holder_selected_contest_delay(), &context.destination_script,
			&funding.channel_transaction_parameters, funding.is_outbound(), obscure_factor,
			holder_commitment_tx, best_block, context.counterparty_node_id, context.channel_id(),
			context.is_manual_broadcast,
		);
		channel_monitor.provide_initial_counterparty_commitment_tx(
			counterparty_initial_commitment_tx.clone(),
		);

		self.context_mut().counterparty_next_commitment_transaction_number -= 1;

		Ok((channel_monitor, counterparty_initial_commitment_tx))
	}

	fn is_v2_established(&self) -> bool;
}

impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for OutboundV1Channel<SP> {
	fn context(&self) -> &ChannelContext<SP> {
		&self.context
	}

	fn context_mut(&mut self) -> &mut ChannelContext<SP> {
		&mut self.context
	}

	fn funding(&self) -> &FundingScope {
		&self.funding
	}

	fn funding_mut(&mut self) -> &mut FundingScope {
		&mut self.funding
	}

	fn received_msg(&self) -> &'static str {
		"funding_signed"
	}

	fn is_v2_established(&self) -> bool {
		false
	}
}

impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for InboundV1Channel<SP> {
	fn context(&self) -> &ChannelContext<SP> {
		&self.context
	}

	fn context_mut(&mut self) -> &mut ChannelContext<SP> {
		&mut self.context
	}

	fn funding(&self) -> &FundingScope {
		&self.funding
	}

	fn funding_mut(&mut self) -> &mut FundingScope {
		&mut self.funding
	}

	fn received_msg(&self) -> &'static str {
		"funding_created"
	}

	fn is_v2_established(&self) -> bool {
		false
	}
}

impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for FundedChannel<SP> {
	fn context(&self) -> &ChannelContext<SP> {
		&self.context
	}

	fn context_mut(&mut self) -> &mut ChannelContext<SP> {
		&mut self.context
	}

	fn funding(&self) -> &FundingScope {
		&self.funding
	}

	fn funding_mut(&mut self) -> &mut FundingScope {
		&mut self.funding
	}

	fn received_msg(&self) -> &'static str {
		"commitment_signed"
	}

	fn is_v2_established(&self) -> bool {
		let channel_parameters = &self.funding().channel_transaction_parameters;
		// This will return false if `counterparty_parameters` is `None`, but for a `FundedChannel`, it
		// should never be `None`.
		debug_assert!(channel_parameters.counterparty_parameters.is_some());
		channel_parameters.counterparty_parameters.as_ref().is_some_and(|counterparty_parameters| {
			self.context().channel_id().is_v2_channel_id(
				&channel_parameters.holder_pubkeys.revocation_basepoint,
				&counterparty_parameters.pubkeys.revocation_basepoint,
			)
		})
	}
}

impl<SP: SignerProvider> ChannelContext<SP> {
	fn new_for_inbound_channel<'a, ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &'a LowerBoundedFeeEstimator<F>, entropy_source: &'a ES,
		signer_provider: &'a SP, counterparty_node_id: PublicKey, their_features: &'a InitFeatures,
		user_id: u128, config: &'a UserConfig, current_chain_height: u32, logger: &'a L,
		trusted_channel_features: Option<TrustedChannelFeatures>, our_funding_satoshis: u64,
		counterparty_pubkeys: ChannelPublicKeys, channel_type: ChannelTypeFeatures,
		holder_selected_channel_reserve_satoshis: u64, msg_channel_reserve_satoshis: u64,
		msg_push_msat: u64, open_channel_fields: msgs::CommonOpenChannelFields,
	) -> Result<(FundingScope, ChannelContext<SP>), ChannelError> {
		let logger = WithContext::from(
			logger,
			Some(counterparty_node_id),
			Some(open_channel_fields.temporary_channel_id),
			None,
		);
		let announce_for_forwarding =
			if (open_channel_fields.channel_flags & 1) == 1 { true } else { false };

		let channel_value_satoshis =
			our_funding_satoshis.saturating_add(open_channel_fields.funding_satoshis);
		if channel_value_satoshis < MIN_CHANNEL_VALUE_SATOSHIS {
			return Err(ChannelError::close(format!(
				"Channel value must be at least 1000 satoshis. It was {channel_value_satoshis}",
			)));
		}

		let channel_keys_id = signer_provider.generate_channel_keys_id(true, user_id);
		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);

		if config.channel_handshake_config.our_to_self_delay < BREAKDOWN_TIMEOUT {
			return Err(ChannelError::close(format!(
				"Configured with an unreasonable our_to_self_delay ({}) putting user funds at risks. It must be greater than {BREAKDOWN_TIMEOUT}",
				config.channel_handshake_config.our_to_self_delay
			)));
		}

		if channel_value_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
			return Err(ChannelError::close(format!(
				"Funding must be smaller than the total bitcoin supply. It was {channel_value_satoshis}"
			)));
		}
		if !channel_type.supports_anchors_zero_fee_htlc_tx()
			&& !channel_type.supports_anchor_zero_fee_commitments()
			&& holder_selected_channel_reserve_satoshis == 0
		{
			return Err(ChannelError::close(
				"0-reserve is not allowed on legacy channels".to_owned(),
			));
		}
		if msg_channel_reserve_satoshis > channel_value_satoshis {
			return Err(ChannelError::close(format!(
				"Bogus channel_reserve_satoshis ({msg_channel_reserve_satoshis}). Must be no greater than channel_value_satoshis: {channel_value_satoshis}"
			)));
		}
		let full_channel_value_msat =
			(channel_value_satoshis - msg_channel_reserve_satoshis) * 1000;
		if msg_push_msat > full_channel_value_msat {
			return Err(ChannelError::close(format!(
				"push_msat {msg_push_msat} was larger than channel amount minus reserve ({full_channel_value_msat})"
			)));
		}
		if open_channel_fields.dust_limit_satoshis > channel_value_satoshis {
			return Err(ChannelError::close(format!(
				"dust_limit_satoshis {} was larger than channel_value_satoshis {channel_value_satoshis}. Peer never wants payout outputs?",
				open_channel_fields.dust_limit_satoshis
			)));
		}
		if open_channel_fields.htlc_minimum_msat >= full_channel_value_msat {
			return Err(ChannelError::close(format!(
				"Minimum htlc value ({}) was larger than full channel value ({full_channel_value_msat})",
				open_channel_fields.htlc_minimum_msat
			)));
		}
		FundedChannel::<SP>::check_remote_fee(
			&channel_type,
			fee_estimator,
			open_channel_fields.commitment_feerate_sat_per_1000_weight,
			None,
			&&logger,
		)?;

		let max_counterparty_selected_contest_delay = u16::min(
			config.channel_handshake_limits.their_to_self_delay,
			MAX_LOCAL_BREAKDOWN_TIMEOUT,
		);
		if open_channel_fields.to_self_delay > max_counterparty_selected_contest_delay {
			return Err(ChannelError::close(format!(
				"They wanted our payments to be delayed by a needlessly long period. Upper limit: {max_counterparty_selected_contest_delay}. Actual: {}",
				open_channel_fields.to_self_delay
			)));
		}
		if open_channel_fields.max_accepted_htlcs < 1 {
			return Err(ChannelError::close(
				"0 max_accepted_htlcs makes for a useless channel".to_owned(),
			));
		}
		if open_channel_fields.max_accepted_htlcs > max_htlcs(&channel_type) {
			return Err(ChannelError::close(format!(
				"max_accepted_htlcs was {}. It must not be larger than {}",
				open_channel_fields.max_accepted_htlcs,
				max_htlcs(&channel_type)
			)));
		}

		// Now check against optional parameters as set by config...
		if channel_value_satoshis < config.channel_handshake_limits.min_funding_satoshis {
			return Err(ChannelError::close(format!(
				"Funding satoshis ({channel_value_satoshis}) is less than the user specified limit ({})",
				config.channel_handshake_limits.min_funding_satoshis
			)));
		}
		if open_channel_fields.htlc_minimum_msat
			> config.channel_handshake_limits.max_htlc_minimum_msat
		{
			return Err(ChannelError::close(format!(
				"htlc_minimum_msat ({}) is higher than the user specified limit ({})",
				open_channel_fields.htlc_minimum_msat,
				config.channel_handshake_limits.max_htlc_minimum_msat
			)));
		}
		if open_channel_fields.max_htlc_value_in_flight_msat
			< config.channel_handshake_limits.min_max_htlc_value_in_flight_msat
		{
			return Err(ChannelError::close(format!(
				"max_htlc_value_in_flight_msat ({}) is less than the user specified limit ({})",
				open_channel_fields.max_htlc_value_in_flight_msat,
				config.channel_handshake_limits.min_max_htlc_value_in_flight_msat
			)));
		}
		if msg_channel_reserve_satoshis
			> config.channel_handshake_limits.max_channel_reserve_satoshis
		{
			return Err(ChannelError::close(format!(
				"channel_reserve_satoshis ({msg_channel_reserve_satoshis}) is higher than the user specified limit ({})",
				config.channel_handshake_limits.max_channel_reserve_satoshis
			)));
		}
		if open_channel_fields.max_accepted_htlcs
			< config.channel_handshake_limits.min_max_accepted_htlcs
		{
			return Err(ChannelError::close(format!(
				"max_accepted_htlcs ({}) is less than the user specified limit ({})",
				open_channel_fields.max_accepted_htlcs,
				config.channel_handshake_limits.min_max_accepted_htlcs
			)));
		}
		if open_channel_fields.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
			return Err(ChannelError::close(format!(
				"dust_limit_satoshis ({}) is less than the implementation limit ({MIN_CHAN_DUST_LIMIT_SATOSHIS})",
				open_channel_fields.dust_limit_satoshis
			)));
		}

		let max_chan_dust_limit_satoshis = if channel_type.supports_anchors_zero_fee_htlc_tx()
			|| channel_type.supports_anchor_zero_fee_commitments()
		{
			MAX_CHAN_DUST_LIMIT_SATOSHIS
		} else {
			MAX_LEGACY_CHAN_DUST_LIMIT_SATOSHIS
		};
		if open_channel_fields.dust_limit_satoshis > max_chan_dust_limit_satoshis {
			return Err(ChannelError::close(format!(
				"dust_limit_satoshis ({}) is greater than the implementation limit ({max_chan_dust_limit_satoshis})",
				open_channel_fields.dust_limit_satoshis
			)));
		}

		// Convert things into internal flags and prep our state:

		if config.channel_handshake_limits.force_announced_channel_preference {
			if config.channel_handshake_config.announce_for_forwarding != announce_for_forwarding {
				return Err(ChannelError::close(String::from(
					"Peer tried to open channel but their announcement preference is different from ours"
				)));
			}
		}

		if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS
			&& holder_selected_channel_reserve_satoshis != 0
		{
			// Protocol level safety check in place, although it should never happen because
			// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS` and `MIN_CHANNEL_VALUE_SATOSHIS`
			return Err(ChannelError::close(format!(
				"Suitable channel reserve not found. remote_channel_reserve was ({holder_selected_channel_reserve_satoshis}). dust_limit_satoshis is ({MIN_CHAN_DUST_LIMIT_SATOSHIS})."
			)));
		}
		if holder_selected_channel_reserve_satoshis * 1000 >= full_channel_value_msat {
			return Err(ChannelError::close(format!(
				"Suitable channel reserve not found. remote_channel_reserve was ({})msats. Channel value is ({full_channel_value_msat} - {msg_push_msat})msats.",
				holder_selected_channel_reserve_satoshis * 1000
			)));
		}
		if msg_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
			log_debug!(
				logger,
				"channel_reserve_satoshis ({msg_channel_reserve_satoshis}) is smaller than our dust limit ({MIN_CHAN_DUST_LIMIT_SATOSHIS}). We can broadcast \
				stale states without any risk, implying this channel is very insecure for our counterparty.");
		}
		if holder_selected_channel_reserve_satoshis < open_channel_fields.dust_limit_satoshis
			&& holder_selected_channel_reserve_satoshis != 0
		{
			return Err(ChannelError::close(format!(
				"Dust limit ({}) too high for the channel reserve we require the remote to keep ({holder_selected_channel_reserve_satoshis})",
				open_channel_fields.dust_limit_satoshis
			)));
		}

		// v1 channel opens set `our_funding_satoshis` to 0, and v2 channel opens set `msg_push_msat` to 0.
		debug_assert!(our_funding_satoshis == 0 || msg_push_msat == 0);
		let value_to_self_msat = our_funding_satoshis * 1000 + msg_push_msat;

		let counterparty_shutdown_scriptpubkey =
			if their_features.supports_upfront_shutdown_script() {
				match &open_channel_fields.shutdown_scriptpubkey {
					&Some(ref script) => {
						// Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
						if script.len() == 0 {
							None
						} else {
							if !script::is_bolt2_compliant(&script, their_features) {
								return Err(ChannelError::close(format!(
								"Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {script}"
							)));
							}
							Some(script.clone())
						}
					},
					// 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
					&None => {
						return Err(ChannelError::close(String::from(
						"Peer is signaling upfront_shutdown but we don't get any script. Use 0-length script to opt-out"
					)));
					},
				}
			} else {
				None
			};

		let shutdown_scriptpubkey =
			if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
				match signer_provider.get_shutdown_scriptpubkey() {
					Ok(scriptpubkey) => Some(scriptpubkey),
					Err(_) => {
						return Err(ChannelError::close(
							"Failed to get upfront shutdown scriptpubkey".to_owned(),
						))
					},
				}
			} else {
				None
			};

		if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
			if !shutdown_scriptpubkey.is_compatible(&their_features) {
				return Err(ChannelError::close(format!(
					"Provided a scriptpubkey format not accepted by peer: {shutdown_scriptpubkey}"
				)));
			}
		}

		let destination_script = match signer_provider.get_destination_script(channel_keys_id) {
			Ok(script) => script,
			Err(_) => {
				return Err(ChannelError::close("Failed to get destination script".to_owned()))
			},
		};

		let mut secp_ctx = Secp256k1::new();
		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());

		let minimum_depth = if trusted_channel_features.is_some_and(|f| f.is_0conf()) {
			Some(0)
		} else {
			Some(cmp::max(config.channel_handshake_config.minimum_depth, 1))
		};

		// TODO(dual_funding): Checks for `funding_feerate_sat_per_1000_weight`?

		let pubkeys = holder_signer.pubkeys(&secp_ctx);

		let funding = FundingScope {
			value_to_self_msat,
			counterparty_selected_channel_reserve_satoshis: Some(msg_channel_reserve_satoshis),
			holder_selected_channel_reserve_satoshis,

			#[cfg(debug_assertions)]
			holder_prev_commitment_tx_balance: Mutex::new((
				value_to_self_msat,
				(channel_value_satoshis * 1000 - msg_push_msat).saturating_sub(value_to_self_msat),
			)),
			#[cfg(debug_assertions)]
			counterparty_prev_commitment_tx_balance: Mutex::new((
				value_to_self_msat,
				(channel_value_satoshis * 1000 - msg_push_msat).saturating_sub(value_to_self_msat),
			)),

			#[cfg(any(test, fuzzing))]
			next_local_fee: Mutex::new(PredictedNextFee::default()),
			#[cfg(any(test, fuzzing))]
			next_remote_fee: Mutex::new(PredictedNextFee::default()),

			channel_transaction_parameters: ChannelTransactionParameters {
				holder_pubkeys: pubkeys,
				holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
				is_outbound_from_holder: false,
				counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
					selected_contest_delay: open_channel_fields.to_self_delay,
					pubkeys: counterparty_pubkeys,
				}),
				funding_outpoint: None,
				splice_parent_funding_txid: None,
				channel_type_features: channel_type.clone(),
				channel_value_satoshis,
			},
			funding_transaction: None,
			funding_tx_confirmed_in: None,
			funding_tx_confirmation_height: 0,
			short_channel_id: None,
			minimum_depth_override: None,
		};
		let channel_context = ChannelContext {
			user_id,

			config: LegacyChannelConfig {
				options: config.channel_config.clone(),
				announce_for_forwarding,
				commit_upfront_shutdown_pubkey: config
					.channel_handshake_config
					.commit_upfront_shutdown_pubkey,
			},

			prev_config: None,

			inbound_handshake_limits_override: None,

			temporary_channel_id: Some(open_channel_fields.temporary_channel_id),
			channel_id: open_channel_fields.temporary_channel_id,
			channel_state: ChannelState::NegotiatingFunding(
				NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT,
			),
			announcement_sigs_state: AnnouncementSigsState::NotSent,
			secp_ctx,

			latest_monitor_update_id: 0,

			holder_signer,
			shutdown_scriptpubkey,
			destination_script,

			counterparty_next_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,

			pending_inbound_htlcs: Vec::new(),
			pending_outbound_htlcs: Vec::new(),
			holding_cell_htlc_updates: Vec::new(),
			pending_update_fee: None,
			holding_cell_update_fee: None,
			next_holder_htlc_id: 0,
			next_counterparty_htlc_id: 0,
			update_time_counter: 1,

			resend_order: RAACommitmentOrder::CommitmentFirst,

			monitor_pending_tx_signatures: false,
			monitor_pending_channel_ready: false,
			monitor_pending_revoke_and_ack: false,
			monitor_pending_commitment_signed: false,
			monitor_pending_forwards: Vec::new(),
			monitor_pending_failures: Vec::new(),
			monitor_pending_finalized_fulfills: Vec::new(),
			monitor_pending_update_adds: Vec::new(),

			signer_pending_revoke_and_ack: false,
			signer_pending_commitment_update: false,
			signer_pending_funding: false,
			signer_pending_closing: false,
			signer_pending_channel_ready: false,
			signer_pending_stale_state_verification: None,

			last_sent_closing_fee: None,
			last_received_closing_sig: None,
			pending_counterparty_closing_signed: None,
			expecting_peer_commitment_signed: false,
			closing_fee_limits: None,
			target_closing_feerate_sats_per_kw: None,

			channel_creation_height: current_chain_height,

			feerate_per_kw: open_channel_fields.commitment_feerate_sat_per_1000_weight,
			counterparty_dust_limit_satoshis: open_channel_fields.dust_limit_satoshis,
			holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
			counterparty_max_htlc_value_in_flight_msat: cmp::min(
				open_channel_fields.max_htlc_value_in_flight_msat,
				channel_value_satoshis * 1000,
			),
			holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(
				channel_value_satoshis,
				announce_for_forwarding,
				&config.channel_handshake_config,
			),
			counterparty_htlc_minimum_msat: open_channel_fields.htlc_minimum_msat,
			holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0
			{
				1
			} else {
				config.channel_handshake_config.our_htlc_minimum_msat
			},
			counterparty_max_accepted_htlcs: open_channel_fields.max_accepted_htlcs,
			holder_max_accepted_htlcs: cmp::min(
				config.channel_handshake_config.our_max_accepted_htlcs,
				max_htlcs(&channel_type),
			),
			minimum_depth,

			counterparty_forwarding_info: None,

			is_batch_funding: None,

			counterparty_next_commitment_point: Some(
				open_channel_fields.first_per_commitment_point,
			),
			counterparty_current_commitment_point: None,
			counterparty_node_id,

			counterparty_shutdown_scriptpubkey,

			commitment_secrets: CounterpartyCommitmentSecrets::new(),

			channel_update_status: ChannelUpdateStatus::Enabled,
			closing_signed_in_flight: false,

			announcement_sigs: None,

			workaround_lnd_bug_4006: None,
			funding_locked_txid_sent_in_reestablish: None,
			sent_message_awaiting_response: None,

			latest_inbound_scid_alias: None,
			outbound_scid_alias: 0,
			historical_scids: Vec::new(),

			channel_pending_event_emitted: false,
			funding_tx_broadcast_safe_event_emitted: false,
			initial_channel_ready_event_emitted: false,

			channel_keys_id,

			local_initiated_shutdown: None,

			blocked_monitor_updates: Vec::new(),

			is_manual_broadcast: false,

			interactive_tx_signing_session: None,
		};

		// check if the funder's amount for the initial commitment tx is sufficient
		// for full fee payment plus a few HTLCs to ensure the channel will be useful.
		let funders_amount_msat =
			funding.get_value_satoshis() * 1000 - funding.get_value_to_self_msat();
		let htlc_candidate = None;
		let addl_nondust_htlc_count = MIN_AFFORDABLE_HTLC_COUNT;
		let dust_exposure_limiting_feerate = channel_context
			.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());
		let (remote_stats, _remote_htlcs) = channel_context
			.get_next_remote_commitment_stats(
				&funding,
				htlc_candidate,
				NextCommitmentView::ValidatingOwnUpdate,
				addl_nondust_htlc_count,
				channel_context.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				ChannelError::close(format!(
					"Funding amount ({} sats) can't even pay fee for initial commitment transaction.",
					funders_amount_msat / 1000
				))
			})?;

		// While it's reasonable for us to not meet the channel reserve initially (if they don't
		// want to push much to us), our counterparty should always have more than our reserve.
		if remote_stats.commitment_stats.counterparty_balance_msat / 1000
			< funding.holder_selected_channel_reserve_satoshis
		{
			return Err(ChannelError::close(
				"Insufficient funding amount for initial reserve".to_owned(),
			));
		}

		Ok((funding, channel_context))
	}

	fn new_for_outbound_channel<'a, ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &'a LowerBoundedFeeEstimator<F>, entropy_source: &'a ES,
		signer_provider: &'a SP, counterparty_node_id: PublicKey, their_features: &'a InitFeatures,
		funding_satoshis: u64, push_msat: u64, user_id: u128, config: &'a UserConfig,
		current_chain_height: u32, outbound_scid_alias: u64,
		temporary_channel_id_fn: Option<impl Fn(&ChannelPublicKeys) -> ChannelId>,
		holder_selected_channel_reserve_satoshis: u64, channel_keys_id: [u8; 32],
		holder_signer: SP::EcdsaSigner, _logger: L,
	) -> Result<(FundingScope, ChannelContext<SP>), APIError> {
		// This will be updated with the counterparty contribution if this is a dual-funded channel
		let channel_value_satoshis = funding_satoshis;

		let holder_selected_contest_delay = config.channel_handshake_config.our_to_self_delay;

		if !their_features.supports_wumbo()
			&& channel_value_satoshis > MAX_FUNDING_SATOSHIS_NO_WUMBO
		{
			return Err(APIError::APIMisuseError {
				err: format!(
					"funding_value must not exceed {MAX_FUNDING_SATOSHIS_NO_WUMBO}, it was {channel_value_satoshis}"
				),
			});
		}
		if channel_value_satoshis >= TOTAL_BITCOIN_SUPPLY_SATOSHIS {
			return Err(APIError::APIMisuseError {
				err: format!(
					"funding_value must be smaller than the total bitcoin supply, it was {channel_value_satoshis}"
				),
			});
		}
		let channel_value_msat = channel_value_satoshis * 1000;
		if push_msat > channel_value_msat {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Push value ({push_msat}) was larger than channel_value ({channel_value_msat})"
				),
			});
		}
		if holder_selected_contest_delay < BREAKDOWN_TIMEOUT {
			return Err(APIError::APIMisuseError {
				err: format!(
				"Configured with an unreasonable our_to_self_delay ({holder_selected_contest_delay}) putting user funds at risks"
			),
			});
		}

		let channel_type = get_initial_channel_type(&config, their_features);
		if !channel_type.supports_anchors_zero_fee_htlc_tx()
			&& !channel_type.supports_anchor_zero_fee_commitments()
			&& holder_selected_channel_reserve_satoshis == 0
		{
			return Err(APIError::APIMisuseError {
				err: "0-reserve is not allowed on legacy channels".to_owned(),
			});
		}
		debug_assert!(!channel_type.supports_any_optional_bits());
		debug_assert!(!channel_type
			.requires_unknown_bits_from(&channelmanager::provided_channel_type_features(&config)));

		let commitment_feerate =
			selected_commitment_sat_per_1000_weight(&fee_estimator, &channel_type);

		let value_to_self_msat = channel_value_satoshis * 1000 - push_msat;

		let mut secp_ctx = Secp256k1::new();
		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());

		let shutdown_scriptpubkey =
			if config.channel_handshake_config.commit_upfront_shutdown_pubkey {
				match signer_provider.get_shutdown_scriptpubkey() {
					Ok(scriptpubkey) => Some(scriptpubkey),
					Err(_) => {
						return Err(APIError::ChannelUnavailable {
							err: "Failed to get shutdown scriptpubkey".to_owned(),
						})
					},
				}
			} else {
				None
			};

		if let Some(shutdown_scriptpubkey) = &shutdown_scriptpubkey {
			if !shutdown_scriptpubkey.is_compatible(&their_features) {
				return Err(APIError::IncompatibleShutdownScript {
					script: shutdown_scriptpubkey.clone(),
				});
			}
		}

		let destination_script = match signer_provider.get_destination_script(channel_keys_id) {
			Ok(script) => script,
			Err(_) => {
				return Err(APIError::ChannelUnavailable {
					err: "Failed to get destination script".to_owned(),
				})
			},
		};

		let pubkeys = holder_signer.pubkeys(&secp_ctx);
		let temporary_channel_id = temporary_channel_id_fn
			.map(|f| f(&pubkeys))
			.unwrap_or_else(|| ChannelId::temporary_from_entropy_source(entropy_source));

		let funding = FundingScope {
			value_to_self_msat,
			counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
			holder_selected_channel_reserve_satoshis,

			// We'll add our counterparty's `funding_satoshis` to these max commitment output assertions
			// when we receive `accept_channel2`.
			#[cfg(debug_assertions)]
			holder_prev_commitment_tx_balance: Mutex::new((
				channel_value_satoshis * 1000 - push_msat,
				push_msat,
			)),
			#[cfg(debug_assertions)]
			counterparty_prev_commitment_tx_balance: Mutex::new((
				channel_value_satoshis * 1000 - push_msat,
				push_msat,
			)),

			#[cfg(any(test, fuzzing))]
			next_local_fee: Mutex::new(PredictedNextFee::default()),
			#[cfg(any(test, fuzzing))]
			next_remote_fee: Mutex::new(PredictedNextFee::default()),

			channel_transaction_parameters: ChannelTransactionParameters {
				holder_pubkeys: pubkeys,
				holder_selected_contest_delay: config.channel_handshake_config.our_to_self_delay,
				is_outbound_from_holder: true,
				counterparty_parameters: None,
				funding_outpoint: None,
				splice_parent_funding_txid: None,
				channel_type_features: channel_type.clone(),
				// We'll add our counterparty's `funding_satoshis` when we receive `accept_channel2`.
				channel_value_satoshis,
			},
			funding_transaction: None,
			funding_tx_confirmed_in: None,
			funding_tx_confirmation_height: 0,
			short_channel_id: None,
			minimum_depth_override: None,
		};
		let channel_context = Self {
			user_id,

			config: LegacyChannelConfig {
				options: config.channel_config.clone(),
				announce_for_forwarding: config.channel_handshake_config.announce_for_forwarding,
				commit_upfront_shutdown_pubkey: config
					.channel_handshake_config
					.commit_upfront_shutdown_pubkey,
			},

			prev_config: None,

			inbound_handshake_limits_override: Some(config.channel_handshake_limits.clone()),

			channel_id: temporary_channel_id,
			temporary_channel_id: Some(temporary_channel_id),
			channel_state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::OUR_INIT_SENT),
			announcement_sigs_state: AnnouncementSigsState::NotSent,
			secp_ctx,

			latest_monitor_update_id: 0,

			holder_signer,
			shutdown_scriptpubkey,
			destination_script,

			counterparty_next_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,

			pending_inbound_htlcs: Vec::new(),
			pending_outbound_htlcs: Vec::new(),
			holding_cell_htlc_updates: Vec::new(),
			pending_update_fee: None,
			holding_cell_update_fee: None,
			next_holder_htlc_id: 0,
			next_counterparty_htlc_id: 0,
			update_time_counter: 1,

			resend_order: RAACommitmentOrder::CommitmentFirst,

			monitor_pending_tx_signatures: false,
			monitor_pending_channel_ready: false,
			monitor_pending_revoke_and_ack: false,
			monitor_pending_commitment_signed: false,
			monitor_pending_forwards: Vec::new(),
			monitor_pending_failures: Vec::new(),
			monitor_pending_finalized_fulfills: Vec::new(),
			monitor_pending_update_adds: Vec::new(),

			signer_pending_revoke_and_ack: false,
			signer_pending_commitment_update: false,
			signer_pending_funding: false,
			signer_pending_closing: false,
			signer_pending_channel_ready: false,
			signer_pending_stale_state_verification: None,

			last_sent_closing_fee: None,
			last_received_closing_sig: None,
			pending_counterparty_closing_signed: None,
			expecting_peer_commitment_signed: false,
			closing_fee_limits: None,
			target_closing_feerate_sats_per_kw: None,

			channel_creation_height: current_chain_height,

			feerate_per_kw: commitment_feerate,
			counterparty_dust_limit_satoshis: 0,
			holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
			counterparty_max_htlc_value_in_flight_msat: 0,
			// We'll adjust this to include our counterparty's `funding_satoshis` when we
			// receive `accept_channel2`.
			holder_max_htlc_value_in_flight_msat: get_holder_max_htlc_value_in_flight_msat(
				channel_value_satoshis,
				config.channel_handshake_config.announce_for_forwarding,
				&config.channel_handshake_config,
			),
			counterparty_htlc_minimum_msat: 0,
			holder_htlc_minimum_msat: if config.channel_handshake_config.our_htlc_minimum_msat == 0
			{
				1
			} else {
				config.channel_handshake_config.our_htlc_minimum_msat
			},
			counterparty_max_accepted_htlcs: 0,
			holder_max_accepted_htlcs: cmp::min(
				config.channel_handshake_config.our_max_accepted_htlcs,
				max_htlcs(&channel_type),
			),
			minimum_depth: None, // Filled in in accept_channel

			counterparty_forwarding_info: None,

			is_batch_funding: None,

			counterparty_next_commitment_point: None,
			counterparty_current_commitment_point: None,
			counterparty_node_id,

			counterparty_shutdown_scriptpubkey: None,

			commitment_secrets: CounterpartyCommitmentSecrets::new(),

			channel_update_status: ChannelUpdateStatus::Enabled,
			closing_signed_in_flight: false,

			announcement_sigs: None,

			workaround_lnd_bug_4006: None,
			funding_locked_txid_sent_in_reestablish: None,
			sent_message_awaiting_response: None,

			latest_inbound_scid_alias: None,
			outbound_scid_alias,
			historical_scids: Vec::new(),

			channel_pending_event_emitted: false,
			funding_tx_broadcast_safe_event_emitted: false,
			initial_channel_ready_event_emitted: false,

			channel_keys_id,

			blocked_monitor_updates: Vec::new(),
			local_initiated_shutdown: None,
			is_manual_broadcast: false,

			interactive_tx_signing_session: None,
		};

		let htlc_candidate = None;
		let addl_nondust_htlc_count = MIN_AFFORDABLE_HTLC_COUNT;
		let dust_exposure_limiting_feerate = channel_context
			.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());
		let _local_stats = channel_context
			.get_next_local_commitment_stats(
				&funding,
				htlc_candidate,
				NextCommitmentView::ValidatingOwnUpdate,
				addl_nondust_htlc_count,
				channel_context.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| APIError::APIMisuseError {
				err: format!(
					"Funding amount ({}) can't even pay fee for initial commitment transaction.",
					funding.get_value_to_self_msat() / 1000
				),
			})?;

		Ok((funding, channel_context))
	}

	/// Allowed in any state (including after shutdown)
	pub fn get_update_time_counter(&self) -> u32 {
		self.update_time_counter
	}

	pub fn get_latest_monitor_update_id(&self) -> u64 {
		self.latest_monitor_update_id
	}

	pub fn get_latest_unblocked_monitor_update_id(&self) -> u64 {
		if self.blocked_monitor_updates.is_empty() {
			return self.get_latest_monitor_update_id();
		}
		self.blocked_monitor_updates[0].update.update_id - 1
	}

	pub fn should_announce(&self) -> bool {
		self.config.announce_for_forwarding
	}

	/// Gets the fee we'd want to charge for adding an HTLC output to this Channel
	/// Allowed in any state (including after shutdown)
	pub fn get_outbound_forwarding_fee_base_msat(&self) -> u32 {
		self.config.options.forwarding_fee_base_msat
	}

	/// Returns true if we've ever received a message from the remote end for this Channel
	pub fn have_received_message(&self) -> bool {
		self.channel_state
			> ChannelState::NegotiatingFunding(NegotiatingFundingFlags::OUR_INIT_SENT)
	}

	/// Returns true if this channel is fully established and not known to be closing.
	/// Allowed in any state (including after shutdown)
	pub fn is_usable(&self) -> bool {
		matches!(self.channel_state, ChannelState::ChannelReady(_))
			&& !self.channel_state.is_local_shutdown_sent()
			&& !self.channel_state.is_remote_shutdown_sent()
			&& !self.monitor_pending_channel_ready
	}

	/// shutdown state returns the state of the channel in its various stages of shutdown
	pub fn shutdown_state(&self) -> ChannelShutdownState {
		match self.channel_state {
			ChannelState::AwaitingChannelReady(_) | ChannelState::ChannelReady(_) => {
				if self.channel_state.is_local_shutdown_sent()
					&& !self.channel_state.is_remote_shutdown_sent()
				{
					ChannelShutdownState::ShutdownInitiated
				} else if (self.channel_state.is_local_shutdown_sent()
					|| self.channel_state.is_remote_shutdown_sent())
					&& !self.closing_negotiation_ready()
				{
					ChannelShutdownState::ResolvingHTLCs
				} else if (self.channel_state.is_local_shutdown_sent()
					|| self.channel_state.is_remote_shutdown_sent())
					&& self.closing_negotiation_ready()
				{
					ChannelShutdownState::NegotiatingClosingFee
				} else {
					ChannelShutdownState::NotShuttingDown
				}
			},
			ChannelState::ShutdownComplete => ChannelShutdownState::ShutdownComplete,
			_ => ChannelShutdownState::NotShuttingDown,
		}
	}

	fn closing_negotiation_ready(&self) -> bool {
		let is_ready_to_close = match self.channel_state {
			ChannelState::AwaitingChannelReady(flags) => {
				flags & FundedStateFlags::ALL
					== FundedStateFlags::LOCAL_SHUTDOWN_SENT
						| FundedStateFlags::REMOTE_SHUTDOWN_SENT
			},
			ChannelState::ChannelReady(flags) => {
				flags
					== FundedStateFlags::LOCAL_SHUTDOWN_SENT
						| FundedStateFlags::REMOTE_SHUTDOWN_SENT
			},
			_ => false,
		};
		self.pending_inbound_htlcs.is_empty()
			&& self.pending_outbound_htlcs.is_empty()
			&& self.pending_update_fee.is_none()
			&& is_ready_to_close
	}

	/// Returns true if this channel is currently available for use. This is a superset of
	/// is_usable() and considers things like the channel being temporarily disabled.
	/// Allowed in any state (including after shutdown)
	pub fn is_live(&self) -> bool {
		self.is_usable() && !self.channel_state.is_peer_disconnected()
	}

	/// Returns true if the peer for this channel is currently connected and we're not waiting on
	/// `channel_reestablish` messages to re-init the channel.
	pub fn is_connected(&self) -> bool {
		!self.channel_state.is_peer_disconnected()
	}

	/// Returns false if our last broadcasted channel_update message has the "channel disabled" bit set
	pub fn is_enabled(&self) -> bool {
		self.is_usable()
			&& match self.channel_update_status {
				ChannelUpdateStatus::Enabled | ChannelUpdateStatus::DisabledStaged(_) => true,
				ChannelUpdateStatus::Disabled | ChannelUpdateStatus::EnabledStaged(_) => false,
			}
	}

	/// Checks whether the channel has any HTLC additions, HTLC removals, or fee updates that have
	/// been sent by either side but not yet irrevocably committed on both commitments because we're
	/// waiting on a pending monitor update or signer request.
	pub fn is_monitor_or_signer_pending_channel_update(&self) -> bool {
		self.channel_state.is_monitor_update_in_progress()
			|| self.signer_pending_revoke_and_ack
			|| self.signer_pending_commitment_update
	}

	/// Checks whether the channel has any HTLC additions, HTLC removals, or fee updates that have
	/// been sent by either side but not yet irrevocably committed on both commitments. Holding cell
	/// updates are not considered because they haven't been sent to the peer yet.
	///
	/// This can be used to satisfy quiescence's requirement when sending `stfu`:
	///  - MUST NOT send `stfu` if any of the sender's htlc additions, htlc removals
	///    or fee updates are pending for either peer.
	///
	/// Note that it is still possible for an update to be pending that's not captured here due to a
	/// pending monitor update or signer request. `is_monitor_or_signer_pending_channel_update`
	/// should also be checked in such cases.
	#[rustfmt::skip]
	fn is_waiting_on_peer_pending_channel_update(&self) -> bool {
		// An update from the local/remote node may be pending on the remote/local commitment since
		// they are not tracked within our state, so we rely on whether any `commitment_signed` or
		// `revoke_and_ack` messages are owed.
		//
		// We check these flags first as they are more likely to be set.
		if self.channel_state.is_awaiting_remote_revoke() || self.expecting_peer_commitment_signed {
			return true;
		}

		// A fee update is pending on either commitment.
		if self.pending_update_fee.is_some() {
			return true;
		}

		if self.pending_inbound_htlcs.iter()
			.any(|htlc| match htlc.state {
				InboundHTLCState::Committed { .. } => false,
				// An HTLC removal from the local node is pending on the remote commitment.
				InboundHTLCState::LocalRemoved(_) => true,
				// An HTLC add from the remote node is pending on the local commitment.
				InboundHTLCState::RemoteAnnounced(_)
					| InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_)
					| InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => true,
			})
		{
			return true;
		}

		self.pending_outbound_htlcs.iter()
			.any(|htlc| match htlc.state {
				OutboundHTLCState::Committed => false,
				// An HTLC add from the local node is pending on the remote commitment.
				OutboundHTLCState::LocalAnnounced(_) => true,
				// An HTLC removal from the remote node is pending on the local commitment.
				OutboundHTLCState::RemoteRemoved(_)
					| OutboundHTLCState::AwaitingRemoteRevokeToRemove(_)
					| OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) => true,
			})
	}

	// Public utilities:

	pub fn channel_id(&self) -> ChannelId {
		self.channel_id
	}

	// Return the `temporary_channel_id` used during channel establishment.
	//
	// Will return `None` for channels created prior to LDK version 0.0.115.
	pub fn temporary_channel_id(&self) -> Option<ChannelId> {
		self.temporary_channel_id
	}

	pub(super) fn minimum_depth(&self, funding: &FundingScope) -> Option<u32> {
		funding.minimum_depth_override.or(self.minimum_depth)
	}

	/// Gets the "user_id" value passed into the construction of this channel. It has no special
	/// meaning and exists only to allow users to have a persistent identifier of a channel.
	pub fn get_user_id(&self) -> u128 {
		self.user_id
	}

	/// Allowed in any state (including after shutdown)
	pub fn latest_inbound_scid_alias(&self) -> Option<u64> {
		self.latest_inbound_scid_alias
	}

	/// Allowed in any state (including after shutdown)
	pub fn outbound_scid_alias(&self) -> u64 {
		self.outbound_scid_alias
	}

	/// Returns the holder signer for this channel.
	#[cfg(any(test, feature = "_test_utils"))]
	pub fn get_mut_signer(&mut self) -> &mut SP::EcdsaSigner {
		return &mut self.holder_signer;
	}

	/// Only allowed immediately after deserialization if get_outbound_scid_alias returns 0,
	/// indicating we were written by LDK prior to 0.0.106 which did not set outbound SCID aliases
	/// or prior to any channel actions during `Channel` initialization.
	pub fn set_outbound_scid_alias(&mut self, outbound_scid_alias: u64) {
		debug_assert_eq!(self.outbound_scid_alias, 0);
		self.outbound_scid_alias = outbound_scid_alias;
	}

	/// Performs checks against necessary constraints after receiving either an `accept_channel` or
	/// `accept_channel2` message.
	pub fn do_accept_channel_checks(
		&mut self, funding: &mut FundingScope, default_limits: &ChannelHandshakeLimits,
		their_features: &InitFeatures, common_fields: &msgs::CommonAcceptChannelFields,
		channel_reserve_satoshis: u64,
	) -> Result<(), ChannelError> {
		let peer_limits = if let Some(ref limits) = self.inbound_handshake_limits_override {
			limits
		} else {
			default_limits
		};

		// Check sanity of message fields:
		if !funding.is_outbound() {
			return Err(ChannelError::close(
				"Got an accept_channel message from an inbound peer".to_owned(),
			));
		}
		if !matches!(self.channel_state, ChannelState::NegotiatingFunding(flags)
			if flags == NegotiatingFundingFlags::OUR_INIT_SENT)
		{
			return Err(ChannelError::close(
				"Got an accept_channel message at a strange time".to_owned(),
			));
		}

		let channel_type = common_fields.channel_type.as_ref().ok_or_else(|| {
			ChannelError::close("option_channel_type assumed to be supported".to_owned())
		})?;
		if channel_type != funding.get_channel_type() {
			return Err(ChannelError::close(String::from(
				"Channel Type in accept_channel didn't match the one sent in open_channel.",
			)));
		}

		if common_fields.dust_limit_satoshis > 21000000 * 100000000 {
			return Err(ChannelError::close(format!(
				"Peer never wants payout outputs? dust_limit_satoshis was {}",
				common_fields.dust_limit_satoshis
			)));
		}
		if channel_reserve_satoshis > funding.get_value_satoshis() {
			return Err(ChannelError::close(format!(
				"Bogus channel_reserve_satoshis ({channel_reserve_satoshis}). Must not be greater than ({})",
				funding.get_value_satoshis()
			)));
		}
		if common_fields.dust_limit_satoshis > funding.holder_selected_channel_reserve_satoshis
			&& funding.holder_selected_channel_reserve_satoshis != 0
		{
			return Err(ChannelError::close(format!(
				"Dust limit ({}) is bigger than our channel reserve ({})",
				common_fields.dust_limit_satoshis, funding.holder_selected_channel_reserve_satoshis
			)));
		}
		if channel_reserve_satoshis
			> funding.get_value_satoshis() - funding.holder_selected_channel_reserve_satoshis
		{
			return Err(ChannelError::close(format!(
				"Bogus channel_reserve_satoshis ({channel_reserve_satoshis}). Must not be greater than channel value minus our reserve ({})",
				funding.get_value_satoshis() - funding.holder_selected_channel_reserve_satoshis
			)));
		}
		let full_channel_value_msat =
			(funding.get_value_satoshis() - channel_reserve_satoshis) * 1000;
		if common_fields.htlc_minimum_msat >= full_channel_value_msat {
			return Err(ChannelError::close(format!(
				"Minimum htlc value ({}) is full channel value ({full_channel_value_msat})",
				common_fields.htlc_minimum_msat
			)));
		}
		let max_delay_acceptable =
			u16::min(peer_limits.their_to_self_delay, MAX_LOCAL_BREAKDOWN_TIMEOUT);
		if common_fields.to_self_delay > max_delay_acceptable {
			return Err(ChannelError::close(format!(
				"They wanted our payments to be delayed by a needlessly long period. Upper limit: {max_delay_acceptable}. Actual: {}",
				common_fields.to_self_delay
			)));
		}
		if common_fields.max_accepted_htlcs < 1 {
			return Err(ChannelError::close(
				"0 max_accepted_htlcs makes for a useless channel".to_owned(),
			));
		}

		let channel_type = funding.get_channel_type();
		if !channel_type.supports_anchors_zero_fee_htlc_tx()
			&& !channel_type.supports_anchor_zero_fee_commitments()
			&& funding.holder_selected_channel_reserve_satoshis == 0
		{
			return Err(ChannelError::close(
				"0-reserve is not allowed on legacy channels".to_owned(),
			));
		}
		if common_fields.max_accepted_htlcs > max_htlcs(channel_type) {
			return Err(ChannelError::close(format!(
				"max_accepted_htlcs was {}. It must not be larger than {}",
				common_fields.max_accepted_htlcs,
				max_htlcs(channel_type)
			)));
		}

		// Now check against optional parameters as set by config...
		if common_fields.htlc_minimum_msat > peer_limits.max_htlc_minimum_msat {
			return Err(ChannelError::close(format!(
				"htlc_minimum_msat ({}) is higher than the user specified limit ({})",
				common_fields.htlc_minimum_msat, peer_limits.max_htlc_minimum_msat
			)));
		}
		if common_fields.max_htlc_value_in_flight_msat
			< peer_limits.min_max_htlc_value_in_flight_msat
		{
			return Err(ChannelError::close(format!(
				"max_htlc_value_in_flight_msat ({}) is less than the user specified limit ({})",
				common_fields.max_htlc_value_in_flight_msat,
				peer_limits.min_max_htlc_value_in_flight_msat
			)));
		}
		if channel_reserve_satoshis > peer_limits.max_channel_reserve_satoshis {
			return Err(ChannelError::close(format!(
				"channel_reserve_satoshis ({channel_reserve_satoshis}) is higher than the user specified limit ({})",
				peer_limits.max_channel_reserve_satoshis
			)));
		}
		if common_fields.max_accepted_htlcs < peer_limits.min_max_accepted_htlcs {
			return Err(ChannelError::close(format!(
				"max_accepted_htlcs ({}) is less than the user specified limit ({})",
				common_fields.max_accepted_htlcs, peer_limits.min_max_accepted_htlcs
			)));
		}
		if common_fields.dust_limit_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS {
			return Err(ChannelError::close(format!(
				"dust_limit_satoshis ({}) is less than the implementation limit ({MIN_CHAN_DUST_LIMIT_SATOSHIS})",
				common_fields.dust_limit_satoshis
			)));
		}

		let max_chan_dust_limit_satoshis = if channel_type.supports_anchors_zero_fee_htlc_tx()
			|| channel_type.supports_anchor_zero_fee_commitments()
		{
			MAX_CHAN_DUST_LIMIT_SATOSHIS
		} else {
			MAX_LEGACY_CHAN_DUST_LIMIT_SATOSHIS
		};
		if common_fields.dust_limit_satoshis > max_chan_dust_limit_satoshis {
			return Err(ChannelError::close(format!(
				"dust_limit_satoshis ({}) is greater than the implementation limit ({max_chan_dust_limit_satoshis})",
				common_fields.dust_limit_satoshis
			)));
		}
		if common_fields.minimum_depth > peer_limits.max_minimum_depth {
			return Err(ChannelError::close(format!(
				"We consider the minimum depth to be unreasonably large. Expected minimum: ({}). Actual: ({})",
				peer_limits.max_minimum_depth, common_fields.minimum_depth
			)));
		}

		let counterparty_shutdown_scriptpubkey =
			if their_features.supports_upfront_shutdown_script() {
				match &common_fields.shutdown_scriptpubkey {
					&Some(ref script) => {
						// Peer is signaling upfront_shutdown and has opt-out with a 0-length script. We don't enforce anything
						if script.len() == 0 {
							None
						} else {
							if !script::is_bolt2_compliant(&script, their_features) {
								return Err(ChannelError::close(format!(
								"Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: {script}"
							)));
							}
							Some(script.clone())
						}
					},
					// 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
					&None => {
						return Err(ChannelError::close(String::from(
						"Peer is signaling upfront_shutdown but we don't get any script. Use 0-length script to opt-out"
					)));
					},
				}
			} else {
				None
			};

		self.counterparty_dust_limit_satoshis = common_fields.dust_limit_satoshis;
		self.counterparty_max_htlc_value_in_flight_msat = cmp::min(
			common_fields.max_htlc_value_in_flight_msat,
			funding.get_value_satoshis() * 1000,
		);
		funding.counterparty_selected_channel_reserve_satoshis = Some(channel_reserve_satoshis);
		self.counterparty_htlc_minimum_msat = common_fields.htlc_minimum_msat;
		self.counterparty_max_accepted_htlcs = common_fields.max_accepted_htlcs;

		if peer_limits.trust_own_funding_0conf {
			self.minimum_depth = Some(common_fields.minimum_depth);
		} else {
			self.minimum_depth = Some(cmp::max(1, common_fields.minimum_depth));
		}

		let counterparty_pubkeys = ChannelPublicKeys {
			funding_pubkey: common_fields.funding_pubkey,
			revocation_basepoint: RevocationBasepoint::from(common_fields.revocation_basepoint),
			payment_point: common_fields.payment_basepoint,
			delayed_payment_basepoint: DelayedPaymentBasepoint::from(
				common_fields.delayed_payment_basepoint,
			),
			htlc_basepoint: HtlcBasepoint::from(common_fields.htlc_basepoint),
		};

		funding.channel_transaction_parameters.counterparty_parameters =
			Some(CounterpartyChannelTransactionParameters {
				selected_contest_delay: common_fields.to_self_delay,
				pubkeys: counterparty_pubkeys,
			});

		self.counterparty_next_commitment_point = Some(common_fields.first_per_commitment_point);
		self.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;

		self.channel_state = ChannelState::NegotiatingFunding(
			NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT,
		);
		self.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.

		Ok(())
	}

	/// Allowed in any state (including after shutdown)
	pub fn get_counterparty_node_id(&self) -> PublicKey {
		self.counterparty_node_id
	}

	/// Allowed in any state (including after shutdown)
	pub fn get_holder_htlc_minimum_msat(&self) -> u64 {
		self.holder_htlc_minimum_msat
	}

	/// Allowed in any state (including after shutdown), but will return none before TheirInitSent
	pub fn get_holder_htlc_maximum_msat(&self, funding: &FundingScope) -> Option<u64> {
		funding.get_htlc_maximum_msat(self.holder_max_htlc_value_in_flight_msat)
	}

	/// Allowed in any state (including after shutdown)
	pub fn get_counterparty_htlc_minimum_msat(&self) -> u64 {
		self.counterparty_htlc_minimum_msat
	}

	/// Allowed in any state (including after shutdown), but will return none before TheirInitSent
	pub fn get_counterparty_htlc_maximum_msat(&self, funding: &FundingScope) -> Option<u64> {
		funding.get_htlc_maximum_msat(self.counterparty_max_htlc_value_in_flight_msat)
	}

	pub fn get_fee_proportional_millionths(&self) -> u32 {
		self.config.options.forwarding_fee_proportional_millionths
	}

	pub fn is_manual_broadcast(&self) -> bool {
		self.is_manual_broadcast
	}

	pub fn get_cltv_expiry_delta(&self) -> u16 {
		cmp::max(self.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
	}

	/// Returns a maximum "sane" fee rate used to reason about our dust exposure.
	/// Will be Some if the `channel_type`'s dust exposure depends on its commitment fee rate, and
	/// None otherwise.
	fn get_dust_exposure_limiting_feerate<F: FeeEstimator>(
		&self, fee_estimator: &LowerBoundedFeeEstimator<F>, channel_type: &ChannelTypeFeatures,
	) -> Option<u32> {
		if channel_type.supports_anchor_zero_fee_commitments() {
			None
		} else {
			Some(fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::MaximumFeeEstimate))
		}
	}

	/// Returns the maximum configured dust exposure.
	///
	/// Uses a default of 1 sat/vbyte if `limiting_feerate_sat_per_kw` is `None` and the dust
	/// exposure policy depends on fee rate.
	pub fn get_max_dust_htlc_exposure_msat(&self, limiting_feerate_sat_per_kw: Option<u32>) -> u64 {
		match self.config.options.max_dust_htlc_exposure {
			MaxDustHTLCExposure::FeeRateMultiplier(multiplier) => {
				(limiting_feerate_sat_per_kw.unwrap_or(250) as u64).saturating_mul(multiplier)
			},
			MaxDustHTLCExposure::FixedLimitMsat(limit) => limit,
		}
	}

	/// Returns the previous [`ChannelConfig`] applied to this channel, if any.
	pub fn prev_config(&self) -> Option<ChannelConfig> {
		self.prev_config.map(|prev_config| prev_config.0)
	}

	// Checks whether we should emit a `ChannelPending` event.
	pub(crate) fn should_emit_channel_pending_event(&mut self) -> bool {
		self.is_funding_broadcastable() && !self.channel_pending_event_emitted
	}

	// Returns whether we already emitted a `ChannelPending` event.
	pub(crate) fn channel_pending_event_emitted(&self) -> bool {
		self.channel_pending_event_emitted
	}

	// Returns whether we already emitted a `FundingTxBroadcastSafe` event.
	pub(crate) fn funding_tx_broadcast_safe_event_emitted(&self) -> bool {
		self.funding_tx_broadcast_safe_event_emitted
	}

	// Remembers that we already emitted a `ChannelPending` event.
	pub(crate) fn set_channel_pending_event_emitted(&mut self) {
		self.channel_pending_event_emitted = true;
	}

	// Checks whether we should emit an initial `ChannelReady` event.
	pub(crate) fn should_emit_initial_channel_ready_event(&mut self) -> bool {
		self.is_usable() && !self.initial_channel_ready_event_emitted
	}

	// Remembers that we already emitted a `ChannelReady` event.
	pub(crate) fn set_initial_channel_ready_event_emitted(&mut self) {
		self.initial_channel_ready_event_emitted = true;
	}

	// Remembers that we already emitted a `FundingTxBroadcastSafe` event.
	pub(crate) fn set_funding_tx_broadcast_safe_event_emitted(&mut self) {
		self.funding_tx_broadcast_safe_event_emitted = true;
	}

	/// Tracks the number of ticks elapsed since the previous [`ChannelConfig`] was updated. Once
	/// [`EXPIRE_PREV_CONFIG_TICKS`] is reached, the previous config is considered expired and will
	/// no longer be considered when forwarding HTLCs.
	pub fn maybe_expire_prev_config(&mut self) {
		if self.prev_config.is_none() {
			return;
		}
		let prev_config = self.prev_config.as_mut().unwrap();
		prev_config.1 += 1;
		if prev_config.1 == EXPIRE_PREV_CONFIG_TICKS {
			self.prev_config = None;
		}
	}

	/// Returns the current [`ChannelConfig`] applied to the channel.
	pub fn config(&self) -> ChannelConfig {
		self.config.options
	}

	/// Updates the channel's config. A bool is returned indicating whether the config update
	/// applied resulted in a new ChannelUpdate message.
	#[rustfmt::skip]
	pub fn update_config(&mut self, config: &ChannelConfig) -> bool {
		let did_channel_update =
			self.config.options.forwarding_fee_proportional_millionths != config.forwarding_fee_proportional_millionths ||
			self.config.options.forwarding_fee_base_msat != config.forwarding_fee_base_msat ||
			self.config.options.cltv_expiry_delta != config.cltv_expiry_delta;
		if did_channel_update {
			self.prev_config = Some((self.config.options, 0));
			// Update the counter, which backs the ChannelUpdate timestamp, to allow the relay
			// policy change to propagate throughout the network.
			self.update_time_counter += 1;
		}
		self.config.options = *config;
		did_channel_update
	}

	/// Marking the channel as manual broadcast is used in order to prevent LDK from automatically
	/// broadcasting the funding transaction.
	///
	/// This is useful if you wish to get hold of the funding transaction before it is broadcasted
	/// via [`Event::FundingTxBroadcastSafe`] event.
	///
	/// [`Event::FundingTxBroadcastSafe`]: crate::events::Event::FundingTxBroadcastSafe
	pub fn set_manual_broadcast(&mut self) {
		self.is_manual_broadcast = true;
	}

	fn can_resume_on_reconnect(&self) -> bool {
		match self.channel_state {
			ChannelState::NegotiatingFunding(_) => false,
			ChannelState::FundingNegotiated(_) => self.interactive_tx_signing_session.is_some(),
			_ => true,
		}
	}

	/// Returns true if this channel can be resume after a restart, implying its past the initial
	/// funding negotiation stages (and any assocated batch channels are similarly past initial
	/// funding negotiation).
	///
	/// This is equivalent to saying the channel can be persisted to disk.
	pub fn can_resume_on_restart(&self) -> bool {
		self.can_resume_on_reconnect()
			&& match self.channel_state {
				ChannelState::AwaitingChannelReady(flags) => !flags.is_waiting_for_batch(),
				_ => true,
			}
	}

	/// Returns true if funding_signed was sent/received and the
	/// funding transaction has been broadcast if necessary.
	fn is_funding_broadcastable(&self) -> bool {
		match self.channel_state {
			ChannelState::NegotiatingFunding(_) => false,
			ChannelState::FundingNegotiated(_) => self
				.interactive_tx_signing_session
				.as_ref()
				.map(|signing_session| signing_session.has_holder_witnesses())
				.unwrap_or(false),
			ChannelState::AwaitingChannelReady(flags) => !flags.is_waiting_for_batch(),
			_ => true,
		}
	}

	#[rustfmt::skip]
	fn unset_funding_info(&mut self, funding: &mut FundingScope) {
		funding.channel_transaction_parameters.funding_outpoint = None;
		self.channel_id = self.temporary_channel_id.expect(
			"temporary_channel_id should be set since unset_funding_info is only called on funded \
			 channels that were unfunded immediately beforehand"
		);
	}

	/// Returns the HTLCs and balance used to evaluate the next local or remote commitment,
	/// accounting for when pending peer updates will be acknowledged. Successful HTLC removals
	/// excluded from the projection are reflected in the balance.
	fn get_next_commitment_projection(
		&self, funding: &FundingScope, local: bool, htlc_candidate: Option<HTLCAmountDirection>,
		commitment_view: NextCommitmentView,
	) -> NextCommitmentProjection {
		let mut next_commitment_htlcs = Vec::with_capacity(
			1 + self.pending_inbound_htlcs.len()
				+ self.pending_outbound_htlcs.len()
				+ self.holding_cell_htlc_updates.len(),
		);
		next_commitment_htlcs.extend(htlc_candidate);

		let mut inbound_claimed_htlc_msat = 0u64;
		let mut outbound_claimed_htlc_msat = 0u64;

		for htlc in self.pending_inbound_htlcs.iter() {
			let included = match (&htlc.state, local) {
				(InboundHTLCState::RemoteAnnounced(..), _) => true,
				(InboundHTLCState::AwaitingRemoteRevokeToAnnounce(..), _) => true,
				(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(..), _) => true,
				(InboundHTLCState::Committed { .. }, _) => true,
				(InboundHTLCState::LocalRemoved(..), true) => true,
				(InboundHTLCState::LocalRemoved(..), false) => false,
			};
			if included {
				next_commitment_htlcs
					.push(HTLCAmountDirection { outbound: false, amount_msat: htlc.amount_msat });
			} else if htlc.state.preimage().is_some() {
				inbound_claimed_htlc_msat += htlc.amount_msat;
			}
		}

		for htlc in self.pending_outbound_htlcs.iter() {
			let included = match (&htlc.state, local) {
				(OutboundHTLCState::LocalAnnounced(..), _) => {
					commitment_view == NextCommitmentView::ValidatingOwnUpdate
				},
				(OutboundHTLCState::Committed, _) => true,
				(OutboundHTLCState::RemoteRemoved(..), true) => false,
				(OutboundHTLCState::RemoteRemoved(..), false) => {
					commitment_view == NextCommitmentView::ValidatingOwnUpdate
				},
				(OutboundHTLCState::AwaitingRemoteRevokeToRemove(..), _) => false,
				(OutboundHTLCState::AwaitingRemovedRemoteRevoke(..), _) => false,
			};
			if included {
				next_commitment_htlcs
					.push(HTLCAmountDirection { outbound: true, amount_msat: htlc.amount_msat });
			} else if htlc.state.preimage().is_some() {
				outbound_claimed_htlc_msat += htlc.amount_msat;
			}
		}

		// TODO: HTLC removals are released from the holding cell at the same time
		// as HTLC additions, so if HTLC additions are applied here, so should HTLC removals.
		// This would allow us to make better use of channel liquidity.
		if let NextCommitmentView::ValidatingOwnUpdate = commitment_view {
			next_commitment_htlcs.extend(self.holding_cell_htlc_updates.iter().filter_map(
				|htlc| {
					if let &HTLCUpdateAwaitingACK::AddHTLC { amount_msat, .. } = htlc {
						Some(HTLCAmountDirection { outbound: true, amount_msat })
					} else {
						None
					}
				},
			));
		}

		let next_value_to_self_msat = funding
			.value_to_self_msat
			.saturating_sub(outbound_claimed_htlc_msat)
			.saturating_add(inbound_claimed_htlc_msat);

		NextCommitmentProjection { next_value_to_self_msat, next_commitment_htlcs }
	}

	fn get_channel_constraints(&self, funding: &FundingScope) -> ChannelConstraints {
		ChannelConstraints {
			holder_dust_limit_satoshis: self.holder_dust_limit_satoshis,
			counterparty_selected_channel_reserve_satoshis: funding
				.counterparty_selected_channel_reserve_satoshis
				.unwrap_or(0),
			counterparty_dust_limit_satoshis: self.counterparty_dust_limit_satoshis,
			holder_selected_channel_reserve_satoshis: funding
				.holder_selected_channel_reserve_satoshis,
			counterparty_htlc_minimum_msat: self.counterparty_htlc_minimum_msat,
			counterparty_max_accepted_htlcs: self.counterparty_max_accepted_htlcs as u64,
			counterparty_max_htlc_value_in_flight_msat: self
				.counterparty_max_htlc_value_in_flight_msat,
		}
	}

	fn get_next_local_commitment_stats(
		&self, funding: &FundingScope, htlc_candidate: Option<HTLCAmountDirection>,
		commitment_view: NextCommitmentView, addl_nondust_htlc_count: usize, feerate_per_kw: u32,
		assume_fee_spike: bool, dust_exposure_limiting_feerate: Option<u32>,
	) -> Result<(ChannelStats, Vec<HTLCAmountDirection>), ()> {
		let NextCommitmentProjection { next_value_to_self_msat, next_commitment_htlcs } =
			self.get_next_commitment_projection(funding, true, htlc_candidate, commitment_view);

		let max_dust_htlc_exposure_msat =
			self.get_max_dust_htlc_exposure_msat(dust_exposure_limiting_feerate);

		let channel_constraints = self.get_channel_constraints(funding);

		let local_stats = SpecTxBuilder {}.get_channel_stats(
			true,
			funding.is_outbound(),
			funding.get_value_satoshis(),
			next_value_to_self_msat,
			&next_commitment_htlcs,
			addl_nondust_htlc_count,
			feerate_per_kw,
			assume_fee_spike,
			dust_exposure_limiting_feerate,
			max_dust_htlc_exposure_msat,
			channel_constraints,
			funding.get_channel_type(),
		)?;

		#[cfg(any(test, fuzzing))]
		{
			if addl_nondust_htlc_count == 0 {
				*funding.next_local_fee.lock().unwrap() = PredictedNextFee {
					predicted_feerate: feerate_per_kw,
					predicted_nondust_htlc_count: local_stats.commitment_stats.nondust_htlc_count,
					predicted_fee_sat: local_stats.commitment_stats.commit_tx_fee_sat,
				};
			} else {
				let predicted_stats = SpecTxBuilder {}
					.get_channel_stats(
						true,
						funding.is_outbound(),
						funding.get_value_satoshis(),
						next_value_to_self_msat,
						&next_commitment_htlcs,
						0,
						feerate_per_kw,
						false,
						dust_exposure_limiting_feerate,
						max_dust_htlc_exposure_msat,
						channel_constraints,
						funding.get_channel_type(),
					)
					.expect("Balance exhausted on local commitment")
					.commitment_stats;
				*funding.next_local_fee.lock().unwrap() = PredictedNextFee {
					predicted_feerate: feerate_per_kw,
					predicted_nondust_htlc_count: predicted_stats.nondust_htlc_count,
					predicted_fee_sat: predicted_stats.commit_tx_fee_sat,
				};
			}
		}

		Ok((local_stats, next_commitment_htlcs))
	}

	fn get_next_remote_commitment_stats(
		&self, funding: &FundingScope, htlc_candidate: Option<HTLCAmountDirection>,
		commitment_view: NextCommitmentView, addl_nondust_htlc_count: usize, feerate_per_kw: u32,
		assume_fee_spike: bool, dust_exposure_limiting_feerate: Option<u32>,
	) -> Result<(ChannelStats, Vec<HTLCAmountDirection>), ()> {
		let NextCommitmentProjection { next_value_to_self_msat, next_commitment_htlcs } =
			self.get_next_commitment_projection(funding, false, htlc_candidate, commitment_view);

		let max_dust_htlc_exposure_msat =
			self.get_max_dust_htlc_exposure_msat(dust_exposure_limiting_feerate);

		let channel_constraints = self.get_channel_constraints(funding);

		let remote_stats = SpecTxBuilder {}.get_channel_stats(
			false,
			funding.is_outbound(),
			funding.get_value_satoshis(),
			next_value_to_self_msat,
			&next_commitment_htlcs,
			addl_nondust_htlc_count,
			feerate_per_kw,
			assume_fee_spike,
			dust_exposure_limiting_feerate,
			max_dust_htlc_exposure_msat,
			channel_constraints,
			funding.get_channel_type(),
		)?;

		#[cfg(any(test, fuzzing))]
		{
			if addl_nondust_htlc_count == 0 {
				*funding.next_remote_fee.lock().unwrap() = PredictedNextFee {
					predicted_feerate: feerate_per_kw,
					predicted_nondust_htlc_count: remote_stats.commitment_stats.nondust_htlc_count,
					predicted_fee_sat: remote_stats.commitment_stats.commit_tx_fee_sat,
				};
			} else {
				let predicted_stats = SpecTxBuilder {}
					.get_channel_stats(
						false,
						funding.is_outbound(),
						funding.get_value_satoshis(),
						next_value_to_self_msat,
						&next_commitment_htlcs,
						0,
						feerate_per_kw,
						false,
						dust_exposure_limiting_feerate,
						max_dust_htlc_exposure_msat,
						channel_constraints,
						funding.get_channel_type(),
					)
					.expect("Balance exhausted on remote commitment")
					.commitment_stats;
				*funding.next_remote_fee.lock().unwrap() = PredictedNextFee {
					predicted_feerate: feerate_per_kw,
					predicted_nondust_htlc_count: predicted_stats.nondust_htlc_count,
					predicted_fee_sat: predicted_stats.commit_tx_fee_sat,
				};
			}
		}

		Ok((remote_stats, next_commitment_htlcs))
	}

	fn validate_update_add_htlc<F: FeeEstimator>(
		&self, funding: &FundingScope, msg: &msgs::UpdateAddHTLC,
		fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<(), ChannelError> {
		if msg.amount_msat > funding.get_value_satoshis() * 1000 {
			return Err(ChannelError::close(
				"Remote side tried to send more than the total value of the channel".to_owned(),
			));
		}

		let dust_exposure_limiting_feerate =
			self.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());
		// Don't include outbound update_add_htlc's in the holding cell, or those which haven't yet been ACK'ed
		// by the counterparty (ie. LocalAnnounced HTLCs)
		// Don't include the extra fee spike buffer HTLC in calculations
		let fee_spike_buffer_htlc = 0;
		let (remote_stats, remote_htlcs) = self
			.get_next_remote_commitment_stats(
				funding,
				Some(HTLCAmountDirection { outbound: false, amount_msat: msg.amount_msat }),
				NextCommitmentView::ValidatingPeerUpdate,
				fee_spike_buffer_htlc,
				self.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				ChannelError::close(String::from("Remote HTLC add would overdraw remaining funds"))
			})?;

		let inbound_htlcs_count = remote_htlcs.iter().filter(|htlc| !htlc.outbound).count();
		let inbound_htlcs_value_msat: u64 = remote_htlcs
			.iter()
			.filter_map(|htlc| (!htlc.outbound).then_some(htlc.amount_msat))
			.sum();

		if inbound_htlcs_count > self.holder_max_accepted_htlcs as usize {
			return Err(ChannelError::close(format!(
				"Remote tried to push more than our max accepted HTLCs ({})",
				self.holder_max_accepted_htlcs,
			)));
		}
		if inbound_htlcs_value_msat > self.holder_max_htlc_value_in_flight_msat {
			return Err(ChannelError::close(format!(
				"Remote HTLC add would put them over our max HTLC value ({})",
				self.holder_max_htlc_value_in_flight_msat,
			)));
		}

		// Check that the remote can afford to pay for this HTLC on-chain at the current
		// feerate_per_kw, while maintaining their channel reserve (as required by the spec).
		//
		// We check holder_selected_channel_reserve_satoshis (we're getting paid, so they have to at least meet
		// the reserve_satoshis we told them to always have as direct payment so that they lose
		// something if we punish them for broadcasting an old state).
		// Note that we don't really care about having a small/no to_remote output in our local
		// commitment transactions, as the purpose of the channel reserve is to ensure we can
		// punish *them* if they misbehave, so we discount any outbound HTLCs which will not be
		// present in the next commitment transaction we send them (at least for fulfilled ones,
		// failed ones won't modify value_to_self).
		// Note that we will send HTLCs which another instance of rust-lightning would think
		// violate the reserve value if we do not do this (as we forget inbound HTLCs from the
		// Channel state once they will not be present in the next received commitment
		// transaction).
		if remote_stats.commitment_stats.counterparty_balance_msat
			< funding.holder_selected_channel_reserve_satoshis * 1000
		{
			return Err(ChannelError::close(
				"Remote HTLC add would put them under remote reserve value".to_owned(),
			));
		}

		// Here we check two things 1) that our local commitment still has at least 1 output
		// (particularly relevant in 0-reserve channels), and 2) that the counterparty can
		// still afford the fee on our commitment if they are the funder.
		let (_local_stats, _local_htlcs) = self
			.get_next_local_commitment_stats(
				funding,
				Some(HTLCAmountDirection { outbound: false, amount_msat: msg.amount_msat }),
				NextCommitmentView::ValidatingPeerUpdate,
				fee_spike_buffer_htlc,
				self.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				ChannelError::close(String::from("Balance exhausted on local commitment"))
			})?;

		Ok(())
	}

	fn validate_update_fee<F: FeeEstimator>(
		&self, funding: &FundingScope, fee_estimator: &LowerBoundedFeeEstimator<F>,
		new_feerate_per_kw: u32,
	) -> Result<(), ChannelError> {
		// Check that we won't be pushed over our dust exposure limit by the feerate increase.
		let dust_exposure_limiting_feerate =
			self.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());
		// Do not include outbound update_add_htlc's in the holding cell, or those which haven't yet been ACK'ed
		// by the counterparty (ie. LocalAnnounced HTLCs)
		let (local_stats, _local_htlcs) = self
			.get_next_local_commitment_stats(
				funding,
				None,
				NextCommitmentView::ValidatingPeerUpdate,
				0,
				new_feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				ChannelError::close(String::from("Funding remote cannot afford proposed new fee"))
			})?;

		local_stats
			.commitment_stats
			.counterparty_balance_msat
			.checked_sub(funding.holder_selected_channel_reserve_satoshis * 1000)
			.ok_or(ChannelError::close(
				"Funding remote cannot afford proposed new fee".to_owned(),
			))?;

		let (remote_stats, _remote_htlcs) = self
			.get_next_remote_commitment_stats(
				funding,
				None,
				NextCommitmentView::ValidatingPeerUpdate,
				0,
				new_feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				ChannelError::close(String::from("Balance exhausted on remote commitment"))
			})?;

		let max_dust_htlc_exposure_msat =
			self.get_max_dust_htlc_exposure_msat(dust_exposure_limiting_feerate);
		if local_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			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)",
					new_feerate_per_kw,
					local_stats.commitment_stats.dust_exposure_msat,
				)
			));
		}
		if remote_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			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)",
					new_feerate_per_kw,
					remote_stats.commitment_stats.dust_exposure_msat,
				)
			));
		}

		Ok(())
	}

	fn validate_commitment_signed<F: FeeEstimator, L: Logger>(
		&self, funding: &FundingScope, transaction_number: u64, commitment_point: PublicKey,
		msg: &msgs::CommitmentSigned, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<
		(HolderCommitmentTransaction, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>),
		ChannelError,
	> {
		let funding_script = funding.get_funding_redeemscript();

		let commitment_data = self.build_commitment_transaction(
			funding,
			transaction_number,
			&commitment_point,
			true,
			false,
			logger,
		);
		let commitment_txid = {
			let trusted_tx = commitment_data.tx.trust();
			let bitcoin_tx = trusted_tx.built_transaction();
			if bitcoin_tx.transaction.output.is_empty() {
				return Err(ChannelError::close(
					"Commitment tx from peer has 0 outputs".to_owned(),
				));
			}

			let sighash = bitcoin_tx.get_sighash_all(&funding_script, funding.get_value_satoshis());

			log_trace!(logger, "Checking commitment tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}",
				log_bytes!(msg.signature.serialize_compact()[..]),
				log_bytes!(funding.counterparty_funding_pubkey().serialize()),
				encode::serialize_hex(&bitcoin_tx.transaction),
				log_bytes!(sighash[..]), encode::serialize_hex(&funding_script),
				&self.channel_id(),
			);
			if let Err(_) = self.secp_ctx.verify_ecdsa(
				&sighash,
				&msg.signature,
				&funding.counterparty_funding_pubkey(),
			) {
				return Err(ChannelError::close(
					"Invalid commitment tx signature from peer".to_owned(),
				));
			}
			bitcoin_tx.txid
		};

		// If our counterparty updated the channel fee in this commitment transaction, check that
		// they can actually afford the new fee now.
		if let Some((new_feerate_per_kw, FeeUpdateState::RemoteAnnounced)) = self.pending_update_fee
		{
			debug_assert!(!funding.is_outbound());
			self.validate_update_fee(funding, fee_estimator, new_feerate_per_kw)?;
		}

		if msg.htlc_signatures.len() != commitment_data.tx.nondust_htlcs().len() {
			return Err(ChannelError::close(format!(
				"Got wrong number of HTLC signatures ({}) from remote. It must be {}",
				msg.htlc_signatures.len(),
				commitment_data.tx.nondust_htlcs().len()
			)));
		}

		let holder_keys = commitment_data.tx.trust().keys();
		for (htlc, counterparty_sig) in
			commitment_data.tx.nondust_htlcs().iter().zip(msg.htlc_signatures.iter())
		{
			assert!(htlc.transaction_output_index.is_some());
			let htlc_tx = chan_utils::build_htlc_transaction(
				&commitment_txid,
				commitment_data.tx.negotiated_feerate_per_kw(),
				funding.get_counterparty_selected_contest_delay().unwrap(),
				&htlc,
				funding.get_channel_type(),
				&holder_keys.broadcaster_delayed_payment_key,
				&holder_keys.revocation_key,
			);

			let htlc_redeemscript =
				chan_utils::get_htlc_redeemscript(&htlc, funding.get_channel_type(), &holder_keys);
			let channel_type = funding.get_channel_type();
			let htlc_sighashtype = if channel_type.supports_anchors_zero_fee_htlc_tx()
				|| channel_type.supports_anchor_zero_fee_commitments()
			{
				EcdsaSighashType::SinglePlusAnyoneCanPay
			} else {
				EcdsaSighashType::All
			};
			let htlc_sighash = hash_to_message!(
				&sighash::SighashCache::new(&htlc_tx)
					.p2wsh_signature_hash(
						0,
						&htlc_redeemscript,
						htlc.to_bitcoin_amount(),
						htlc_sighashtype
					)
					.unwrap()[..]
			);
			log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}.",
				log_bytes!(counterparty_sig.serialize_compact()[..]),
				log_bytes!(holder_keys.countersignatory_htlc_key.to_public_key().serialize()),
				encode::serialize_hex(&htlc_tx),
				log_bytes!(htlc_sighash[..]),
				encode::serialize_hex(&htlc_redeemscript),
				&self.channel_id(),
			);
			if let Err(_) = self.secp_ctx.verify_ecdsa(
				&htlc_sighash,
				&counterparty_sig,
				&holder_keys.countersignatory_htlc_key.to_public_key(),
			) {
				return Err(ChannelError::close("Invalid HTLC tx signature from peer".to_owned()));
			}
		}

		let holder_commitment_tx = HolderCommitmentTransaction::new(
			commitment_data.tx,
			msg.signature,
			msg.htlc_signatures.clone(),
			&funding.get_holder_pubkeys().funding_pubkey,
			funding.counterparty_funding_pubkey(),
		);

		self.holder_signer
			.validate_holder_commitment(
				&holder_commitment_tx,
				commitment_data.outbound_htlc_preimages,
			)
			.map_err(|_| ChannelError::close("Failed to validate our commitment".to_owned()))?;

		Ok((holder_commitment_tx, commitment_data.htlcs_included))
	}

	fn can_send_update_fee<F: FeeEstimator, L: Logger>(
		&self, funding: &FundingScope, feerate_per_kw: u32,
		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> bool {
		// Before proposing a feerate update, check that we can actually afford the new fee.
		let dust_exposure_limiting_feerate =
			self.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());
		// Include outbound update_add_htlc's in the holding cell, and those which haven't yet been ACK'ed by
		// the counterparty (ie. LocalAnnounced HTLCs)
		let (remote_stats, _remote_htlcs) = if let Ok(stats) = self
			.get_next_remote_commitment_stats(
				funding,
				None,
				NextCommitmentView::ValidatingOwnUpdate,
				CONCURRENT_INBOUND_HTLC_FEE_BUFFER as usize,
				feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			) {
			stats
		} else {
			log_debug!(
				logger,
				"Cannot afford to send new feerate due to balance exhausted on remote commitment",
			);
			return false;
		};
		// Note that `stats.commit_tx_fee_sat` accounts for any HTLCs that transition from non-dust to dust
		// under a higher feerate (in the case where HTLC-transactions pay endogenous fees).
		if remote_stats.commitment_stats.holder_balance_msat
			< funding.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000
		{
			//TODO: auto-close after a number of failures?
			log_debug!(logger, "Cannot afford to send new feerate at {}", feerate_per_kw);
			return false;
		}

		// Note, we evaluate pending htlc "preemptive" trimmed-to-dust threshold at the proposed
		// `feerate_per_kw`.
		let max_dust_htlc_exposure_msat =
			self.get_max_dust_htlc_exposure_msat(dust_exposure_limiting_feerate);
		if remote_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			log_debug!(
				logger,
				"Cannot afford to send new feerate at {} without infringing max dust htlc exposure",
				feerate_per_kw,
			);
			return false;
		}

		let (local_stats, _local_htlcs) = if let Ok(stats) = self.get_next_local_commitment_stats(
			funding,
			None,
			NextCommitmentView::ValidatingOwnUpdate,
			CONCURRENT_INBOUND_HTLC_FEE_BUFFER as usize,
			feerate_per_kw,
			false,
			dust_exposure_limiting_feerate,
		) {
			stats
		} else {
			log_debug!(
				logger,
				"Cannot afford to send new feerate due to balance exhausted on local commitment",
			);
			return false;
		};
		if local_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			log_debug!(
				logger,
				"Cannot afford to send new feerate at {} without infringing max dust htlc exposure",
				feerate_per_kw,
			);
			return false;
		}

		return true;
	}

	fn can_accept_incoming_htlc<L: Logger>(
		&self, funding: &FundingScope, dust_exposure_limiting_feerate: Option<u32>, logger: &L,
	) -> Result<(), LocalHTLCFailureReason> {
		// The fee spike buffer (an additional nondust HTLC) we keep for the remote if the channel
		// is not zero fee. This deviates from the spec because the fee spike buffer requirement
		// doesn't exist on the receiver's side, only on the sender's.
		let fee_spike_buffer_htlc =
			if funding.get_channel_type().supports_anchor_zero_fee_commitments() { 0 } else { 1 };
		// While these HTLCs may currently be unknown to our counterparty, they can
		// end up in commitments soon. Moreover, we are considering failing a
		// single HTLC here, not the entire channel, so we opt to be conservative
		// in what we accept to forward.
		// Similar reasoning as above
		let feerate =
			cmp::max(self.feerate_per_kw, self.pending_update_fee.map(|(fee, _)| fee).unwrap_or(0));
		// A `None` `HTLCCandidate` is used as in this case because we're already accounting for
		// the incoming HTLC as it has been fully committed by both sides.
		let (local_stats, _local_htlcs) = self
			.get_next_local_commitment_stats(
				funding,
				None,
				NextCommitmentView::ValidatingOwnUpdate,
				fee_spike_buffer_htlc,
				feerate,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				log_trace!(
					logger,
					"Attempting to fail HTLC due to balance exhausted on local commitment"
				);
				LocalHTLCFailureReason::ChannelBalanceOverdrawn
			})?;
		let (remote_stats, _remote_htlcs) = self
			.get_next_remote_commitment_stats(
				funding,
				None,
				NextCommitmentView::ValidatingOwnUpdate,
				fee_spike_buffer_htlc,
				feerate,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| {
				log_trace!(
					logger,
					"Attempting to fail HTLC due to balance exhausted on remote commitment"
				);
				LocalHTLCFailureReason::ChannelBalanceOverdrawn
			})?;

		let max_dust_htlc_exposure_msat =
			self.get_max_dust_htlc_exposure_msat(dust_exposure_limiting_feerate);
		if remote_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			// Note that the total dust exposure includes both the dust HTLCs and the excess mining fees of
			// the counterparty commitment transaction
			log_info!(
				logger,
				"Cannot accept value that would put our total dust exposure at {} over the limit {} on counterparty commitment tx",
			        remote_stats.commitment_stats.dust_exposure_msat,
				max_dust_htlc_exposure_msat,
			);
			return Err(LocalHTLCFailureReason::DustLimitCounterparty);
		}
		if local_stats.commitment_stats.dust_exposure_msat > max_dust_htlc_exposure_msat {
			log_info!(
				logger,
				"Cannot accept value that would put our exposure to dust HTLCs at {} over the limit {} on holder commitment tx",
				local_stats.commitment_stats.dust_exposure_msat,
				max_dust_htlc_exposure_msat,
			);
			return Err(LocalHTLCFailureReason::DustLimitHolder);
		}

		if !funding.is_outbound() {
			// Note that with anchor outputs we are no longer as sensitive to fee spikes, so we don't need
			// to account for them.
			let (remote_stats, _remote_htlcs) = self
				.get_next_remote_commitment_stats(
					funding,
					None,
					NextCommitmentView::ValidatingOwnUpdate,
					fee_spike_buffer_htlc,
					feerate,
					true,
					dust_exposure_limiting_feerate,
				)
				.map_err(|()| {
					log_trace!(
						logger,
						"Attempting to fail HTLC due to balance exhausted on remote commitment"
					);
					LocalHTLCFailureReason::FeeSpikeBuffer
				})?;
			if remote_stats.commitment_stats.counterparty_balance_msat
				< funding.holder_selected_channel_reserve_satoshis * 1000
			{
				log_info!(
					logger,
					"Attempting to fail HTLC due to fee spike buffer violation. Rebalancing is required.",

				);
				return Err(LocalHTLCFailureReason::FeeSpikeBuffer);
			}
		}

		Ok(())
	}

	#[inline]
	#[rustfmt::skip]
	fn get_commitment_feerate(&self, funding: &FundingScope, generated_by_local: bool) -> u32 {
		let mut feerate_per_kw = self.feerate_per_kw;
		if let Some((feerate, update_state)) = self.pending_update_fee {
			if match update_state {
				// Note that these match the inclusion criteria when scanning
				// pending_inbound_htlcs below.
				FeeUpdateState::RemoteAnnounced => { debug_assert!(!funding.is_outbound()); !generated_by_local },
				FeeUpdateState::AwaitingRemoteRevokeToAnnounce => { debug_assert!(!funding.is_outbound()); !generated_by_local },
				FeeUpdateState::Outbound => { assert!(funding.is_outbound()); generated_by_local },
			} {
				feerate_per_kw = feerate;
			}
		}

		feerate_per_kw
	}

	/// Transaction nomenclature is somewhat confusing here as there are many different cases - a
	/// transaction is referred to as "a's transaction" implying that a will be able to broadcast
	/// the transaction. Thus, b will generally be sending a signature over such a transaction to
	/// a, and a can revoke the transaction by providing b the relevant per_commitment_secret. As
	/// such, a transaction is generally the result of b increasing the amount paid to a (or adding
	/// an HTLC to a).
	/// @local is used only to convert relevant internal structures which refer to remote vs local
	/// to decide value of outputs and direction of HTLCs.
	/// @generated_by_local is used to determine *which* HTLCs to include - noting that the HTLC
	/// state may indicate that one peer has informed the other that they'd like to add an HTLC but
	/// have not yet committed it. Such HTLCs will only be included in transactions which are being
	/// generated by the peer which proposed adding the HTLCs, and thus we need to understand both
	/// which peer generated this transaction and "to whom" this transaction flows.
	#[inline]
	#[rustfmt::skip]
	fn build_commitment_transaction<L: Logger>(&self, funding: &FundingScope, commitment_number: u64, per_commitment_point: &PublicKey, local: bool, generated_by_local: bool, logger: &L) -> CommitmentData<'_> {
		let broadcaster_dust_limit_sat = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
		let feerate_per_kw = self.get_commitment_feerate(funding, generated_by_local);

		let num_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
		let mut htlcs_included: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
		let mut value_to_self_claimed_msat = 0;
		let mut value_to_remote_claimed_msat = 0;

		log_trace!(logger, "Building commitment transaction number {} (really {} xor {}) for channel {} for {}, generated by {} with fee {}...",
			commitment_number, (INITIAL_COMMITMENT_NUMBER - commitment_number),
			get_commitment_transaction_number_obscure_factor(&funding.get_holder_pubkeys().payment_point, &funding.get_counterparty_pubkeys().payment_point, funding.is_outbound()),
			self.channel_id,
			if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);

		macro_rules! get_htlc_in_commitment {
			($htlc: expr, $offered: expr) => {
				HTLCOutputInCommitment {
					offered: $offered,
					amount_msat: $htlc.amount_msat,
					cltv_expiry: $htlc.cltv_expiry,
					payment_hash: $htlc.payment_hash,
					transaction_output_index: None,
				}
			}
		}

		macro_rules! add_htlc_output {
			($htlc: expr, $outbound: expr, $source: expr) => {
				let htlc = get_htlc_in_commitment!($htlc, $outbound == local);
				htlcs_included.push((htlc, $source));
			}
		}

		let mut inbound_htlc_preimages: Vec<PaymentPreimage> = Vec::new();
		let mut outbound_htlc_preimages: Vec<PaymentPreimage> = Vec::new();

		for htlc in self.pending_inbound_htlcs.iter() {
			if htlc.state.included_in_commitment(generated_by_local) {
				log_trace!(logger, "   ...including inbound {} HTLC {} (hash {}) with value {}", htlc.state, htlc.htlc_id, htlc.payment_hash, htlc.amount_msat);
				add_htlc_output!(htlc, false, None);
			} else {
				log_trace!(logger, "   ...not including inbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, htlc.payment_hash, htlc.amount_msat, htlc.state);
				if let Some(preimage) = htlc.state.preimage() {
					inbound_htlc_preimages.push(preimage);
					value_to_self_claimed_msat += htlc.amount_msat;
				}
			}
		};

		for htlc in self.pending_outbound_htlcs.iter() {
			if let Some(preimage) = htlc.state.preimage() {
				outbound_htlc_preimages.push(preimage);
			}
			if htlc.state.included_in_commitment(generated_by_local) {
				log_trace!(logger, "   ...including outbound {} HTLC {} (hash {}) with value {}", htlc.state, htlc.htlc_id, htlc.payment_hash, htlc.amount_msat);
				add_htlc_output!(htlc, true, Some(&htlc.source));
			} else {
				log_trace!(logger, "   ...not including outbound HTLC {} (hash {}) with value {} due to state ({})", htlc.htlc_id, htlc.payment_hash, htlc.amount_msat, htlc.state);
				if htlc.state.preimage().is_some() {
					value_to_remote_claimed_msat += htlc.amount_msat;
				}
			}
		};

		// # Panics
		//
		// After all HTLC claims have been accounted for, the local balance MUST remain greater than or equal to 0.

		let value_to_self_msat = (funding.value_to_self_msat + value_to_self_claimed_msat).checked_sub(value_to_remote_claimed_msat).unwrap();

		let (tx, _stats) = SpecTxBuilder {}.build_commitment_transaction(
			local,
			commitment_number,
			per_commitment_point,
			&funding.channel_transaction_parameters,
			&self.secp_ctx,
			value_to_self_msat,
			htlcs_included.iter().map(|(htlc, _source)| htlc).cloned().collect(),
			feerate_per_kw,
			broadcaster_dust_limit_sat,
			logger,
		);
		#[cfg(any(test, fuzzing))]
		{
			let PredictedNextFee { predicted_feerate, predicted_nondust_htlc_count, predicted_fee_sat } = if local { *funding.next_local_fee.lock().unwrap() } else { *funding.next_remote_fee.lock().unwrap() };
			if predicted_feerate == tx.negotiated_feerate_per_kw() && predicted_nondust_htlc_count == tx.nondust_htlcs().len() {
				assert_eq!(predicted_fee_sat, _stats.commit_tx_fee_sat);
			}
		}
		#[cfg(debug_assertions)]
		{
			// Make sure that the to_self/to_remote is always either past the appropriate
			// channel_reserve *or* it is making progress towards it.
			let mut broadcaster_prev_commitment_balance = if generated_by_local {
				funding.holder_prev_commitment_tx_balance.lock().unwrap()
			} else {
				funding.counterparty_prev_commitment_tx_balance.lock().unwrap()
			};

			// This assumes that once our balance rises above the counterparty selected
			// reserve, it never drops below again. But we allow our counterparty to
			// push us under our reserve when we are the funder and they add a HTLC, as
			// this is really their problem. Hence, we only run this assert in tests.
			#[cfg(test)]
			if _stats.local_balance_before_fee_msat / 1000 < funding.counterparty_selected_channel_reserve_satoshis.unwrap() {
				// If the local balance is below the reserve on this new commitment, it MUST be
				// greater than or equal to the one on the previous commitment.
				debug_assert!(broadcaster_prev_commitment_balance.0 <= _stats.local_balance_before_fee_msat);
			}
			broadcaster_prev_commitment_balance.0 = _stats.local_balance_before_fee_msat;

			if _stats.remote_balance_before_fee_msat / 1000 < funding.holder_selected_channel_reserve_satoshis {
				// If the remote balance is below the reserve on this new commitment, it MUST be
				// greater than or equal to the one on the previous commitment.
				debug_assert!(broadcaster_prev_commitment_balance.1 <= _stats.remote_balance_before_fee_msat);
			}
			broadcaster_prev_commitment_balance.1 = _stats.remote_balance_before_fee_msat;
		}

		// This populates the HTLC-source table with the indices from the HTLCs in the commitment
		// transaction.
		//
		// This brute-force search is O(n^2) over ~1k HTLCs in the worst case. This case is very
		// rare at the moment.
		for nondust_htlc in tx.nondust_htlcs() {
			let htlc = htlcs_included
				.iter_mut()
				.filter(|(htlc, _source)| htlc.transaction_output_index.is_none())
				.find_map(|(htlc, _source)| {
					if htlc.is_data_equal(nondust_htlc) {
						Some(htlc)
					} else {
						None
					}
				})
				.unwrap();
			htlc.transaction_output_index = Some(nondust_htlc.transaction_output_index.unwrap());
		}

		// This places the non-dust HTLC-source pairs first, in the order they appear in the
		// commitment transaction, followed by the dust HTLC-source pairs.
		htlcs_included.sort_unstable_by(|(htlc_a, _), (htlc_b, _)| {
			match (htlc_a.transaction_output_index, htlc_b.transaction_output_index) {
				// `None` is smaller than `Some`, but we want `Some` ordered before `None` in the vector
				(None, Some(_)) => cmp::Ordering::Greater,
				(Some(_), None) => cmp::Ordering::Less,
				(l, r) => cmp::Ord::cmp(&l, &r),
			}
		});

		CommitmentData {
			tx,
			htlcs_included,
			inbound_htlc_preimages,
			outbound_htlc_preimages,
		}
	}

	pub fn get_feerate_sat_per_1000_weight(&self) -> u32 {
		self.feerate_per_kw
	}

	pub fn get_dust_buffer_feerate(&self, outbound_feerate_update: Option<u32>) -> u32 {
		// When calculating our exposure to dust HTLCs, we assume that the channel feerate
		// may, at any point, increase by at least 10 sat/vB (i.e 2530 sat/kWU) or 25%,
		// whichever is higher. This ensures that we aren't suddenly exposed to significantly
		// more dust balance if the feerate increases when we have several HTLCs pending
		// which are near the dust limit.
		let mut feerate_per_kw = self.feerate_per_kw;
		// If there's a pending update fee, use it to ensure we aren't under-estimating
		// potential feerate updates coming soon.
		if let Some((feerate, _)) = self.pending_update_fee {
			feerate_per_kw = cmp::max(feerate_per_kw, feerate);
		}
		if let Some(feerate) = outbound_feerate_update {
			feerate_per_kw = cmp::max(feerate_per_kw, feerate);
		}
		let feerate_plus_quarter = feerate_per_kw.checked_mul(1250).map(|v| v / 1000);
		cmp::max(feerate_per_kw.saturating_add(2530), feerate_plus_quarter.unwrap_or(u32::MAX))
	}

	/// Get forwarding information for the counterparty.
	pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
		self.counterparty_forwarding_info.clone()
	}

	/// Returns information on all pending inbound HTLCs.
	#[rustfmt::skip]
	pub fn get_pending_inbound_htlc_details(&self, funding: &FundingScope) -> Vec<InboundHTLCDetails> {
		let mut holding_cell_states = new_hash_map();
		for holding_cell_update in self.holding_cell_htlc_updates.iter() {
			match holding_cell_update {
				HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
					holding_cell_states.insert(
						htlc_id,
						InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFulfill,
					);
				},
				HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => {
					holding_cell_states.insert(
						htlc_id,
						InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail,
					);
				},
				HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } => {
					holding_cell_states.insert(
						htlc_id,
						InboundHTLCStateDetails::AwaitingRemoteRevokeToRemoveFail,
					);
				},
				// Outbound HTLC.
				HTLCUpdateAwaitingACK::AddHTLC { .. } => {},
			}
		}
		let mut inbound_details = Vec::new();

		let dust_buffer_feerate = self.get_dust_buffer_feerate(None);
		let (htlc_success_tx_fee_sat, _) = second_stage_tx_fees_sat(
			funding.get_channel_type(), dust_buffer_feerate,
		);
		let holder_dust_limit_success_sat = htlc_success_tx_fee_sat + self.holder_dust_limit_satoshis;
		for htlc in self.pending_inbound_htlcs.iter() {
			if let Some(state_details) = (&htlc.state).into() {
				inbound_details.push(InboundHTLCDetails{
					htlc_id: htlc.htlc_id,
					amount_msat: htlc.amount_msat,
					cltv_expiry: htlc.cltv_expiry,
					payment_hash: htlc.payment_hash,
					state: Some(holding_cell_states.remove(&htlc.htlc_id).unwrap_or(state_details)),
					is_dust: htlc.amount_msat / 1000 < holder_dust_limit_success_sat,
				});
			}
		}
		inbound_details
	}

	/// Returns information on all pending outbound HTLCs.
	#[rustfmt::skip]
	pub fn get_pending_outbound_htlc_details(&self, funding: &FundingScope) -> Vec<OutboundHTLCDetails> {
		let mut outbound_details = Vec::new();

		let dust_buffer_feerate = self.get_dust_buffer_feerate(None);
		let (_, htlc_timeout_tx_fee_sat) = second_stage_tx_fees_sat(
			funding.get_channel_type(), dust_buffer_feerate,
		);
		let holder_dust_limit_timeout_sat = htlc_timeout_tx_fee_sat + self.holder_dust_limit_satoshis;
		for htlc in self.pending_outbound_htlcs.iter() {
			outbound_details.push(OutboundHTLCDetails{
				htlc_id: Some(htlc.htlc_id),
				amount_msat: htlc.amount_msat,
				cltv_expiry: htlc.cltv_expiry,
				payment_hash: htlc.payment_hash,
				skimmed_fee_msat: htlc.skimmed_fee_msat,
				state: Some((&htlc.state).into()),
				is_dust: htlc.amount_msat / 1000 < holder_dust_limit_timeout_sat,
			});
		}
		for holding_cell_update in self.holding_cell_htlc_updates.iter() {
			if let HTLCUpdateAwaitingACK::AddHTLC {
				amount_msat,
				cltv_expiry,
				payment_hash,
				skimmed_fee_msat,
				..
			} = *holding_cell_update {
				outbound_details.push(OutboundHTLCDetails{
					htlc_id: None,
					amount_msat: amount_msat,
					cltv_expiry: cltv_expiry,
					payment_hash: payment_hash,
					skimmed_fee_msat: skimmed_fee_msat,
					state: Some(OutboundHTLCStateDetails::AwaitingRemoteRevokeToAdd),
					is_dust: amount_msat / 1000 < holder_dust_limit_timeout_sat,
				});
			}
		}
		outbound_details
	}

	fn get_available_balances_for_scope<F: FeeEstimator>(
		&self, funding: &FundingScope, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<AvailableBalances, ()> {
		let htlc_candidate = None;
		let addl_nondust_htlc_count = 0;
		let dust_exposure_limiting_feerate =
			self.get_dust_exposure_limiting_feerate(&fee_estimator, funding.get_channel_type());

		let balances = self
			.get_next_remote_commitment_stats(
				funding,
				htlc_candidate,
				NextCommitmentView::ValidatingOwnUpdate,
				addl_nondust_htlc_count,
				self.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map(|(remote_stats, _)| remote_stats.available_balances)?;

		#[cfg(debug_assertions)]
		if balances.next_outbound_htlc_limit_msat >= balances.next_outbound_htlc_minimum_msat
			&& balances.next_outbound_htlc_limit_msat != 0
		{
			let (remote_stats, _remote_htlcs) = self
				.get_next_remote_commitment_stats(
					funding,
					Some(HTLCAmountDirection {
						outbound: true,
						// Note that this likely creates a non-dust HTLC, we could add a check for the
						// biggest dust HTLC to make sure we still have a broadcastable commitment in
						// that case.
						amount_msat: balances.next_outbound_htlc_limit_msat,
					}),
					NextCommitmentView::ValidatingOwnUpdate,
					addl_nondust_htlc_count,
					self.feerate_per_kw,
					false,
					dust_exposure_limiting_feerate,
				)
				.unwrap();
			assert!(
				remote_stats.commitment_stats.holder_balance_msat
					>= funding.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000
			);
		}

		Ok(balances)
	}

	#[rustfmt::skip]
	fn if_unbroadcasted_funding<F, O>(&self, f: F) -> Option<O> where F: Fn() -> Option<O> {
		match self.channel_state {
			ChannelState::FundingNegotiated(_) => f(),
			ChannelState::AwaitingChannelReady(flags) =>
				if flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH) ||
					flags.is_set(FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS.into())
				{
					f()
				} else {
					None
				},
			_ => None,
		}
	}

	/// Returns the transaction if there is a pending funding transaction that is yet to be
	/// broadcast.
	///
	/// Note that if [`Self::is_manual_broadcast`] is true the transaction will be a dummy
	/// transaction.
	pub fn unbroadcasted_funding(&self, funding: &FundingScope) -> Option<Transaction> {
		self.if_unbroadcasted_funding(|| funding.funding_transaction.clone())
	}

	/// Returns the transaction ID if there is a pending funding transaction that is yet to be
	/// broadcast.
	pub fn unbroadcasted_funding_txid(&self, funding: &FundingScope) -> Option<Txid> {
		self.if_unbroadcasted_funding(|| {
			funding.channel_transaction_parameters.funding_outpoint.map(|txo| txo.txid)
		})
	}

	/// Returns whether the channel is funded in a batch.
	pub fn is_batch_funding(&self) -> bool {
		self.is_batch_funding.is_some()
	}

	/// Returns the transaction ID if there is a pending batch funding transaction that is yet to be
	/// broadcast.
	pub fn unbroadcasted_batch_funding_txid(&self, funding: &FundingScope) -> Option<Txid> {
		self.unbroadcasted_funding_txid(funding).filter(|_| self.is_batch_funding())
	}

	/// Shuts down this Channel (no more calls into this Channel may be made afterwards except
	/// those explicitly stated to be alowed after shutdown, e.g. some simple getters).
	fn force_shutdown(
		&mut self, funding: &FundingScope, mut closure_reason: ClosureReason,
	) -> ShutdownResult {
		// Note that we MUST only generate a monitor update that indicates force-closure - we're
		// called during initialization prior to the chain_monitor in the encompassing ChannelManager
		// being fully configured in some cases. Thus, its likely any monitor events we generate will
		// be delayed in being processed! See the docs for `ChannelManagerReadArgs` for more.
		assert!(!matches!(self.channel_state, ChannelState::ShutdownComplete));

		let broadcast = self.is_funding_broadcastable();

		// We go ahead and "free" any holding cell HTLCs or HTLCs we haven't yet committed to and
		// return them to fail the payment.
		let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
		let counterparty_node_id = self.get_counterparty_node_id();
		for htlc_update in self.holding_cell_htlc_updates.drain(..) {
			match htlc_update {
				HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. } => {
					dropped_outbound_htlcs.push((
						source,
						payment_hash,
						counterparty_node_id,
						self.channel_id,
					));
				},
				_ => {},
			}
		}

		// Once we're closed, the `ChannelMonitor` is responsible for resolving any remaining
		// HTLCs. However, in the specific case of us pushing new HTLC(s) to the counterparty in
		// the latest commitment transaction that we haven't actually sent due to a block
		// `ChannelMonitorUpdate`, we may have some HTLCs that the `ChannelMonitor` won't know
		// about and thus really need to be included in `dropped_outbound_htlcs`.
		'htlc_iter: for htlc in self.pending_outbound_htlcs.iter() {
			if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
				for update in self.blocked_monitor_updates.iter() {
					for update in update.update.updates.iter() {
						let have_htlc = match update {
							ChannelMonitorUpdateStep::LatestCounterpartyCommitment {
								htlc_data,
								..
							} => {
								let dust =
									htlc_data.dust_htlcs.iter().map(|(_, source)| source.as_ref());
								let nondust =
									htlc_data.nondust_htlc_sources.iter().map(|s| Some(s));
								dust.chain(nondust).any(|source| source == Some(&htlc.source))
							},
							ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
								htlc_outputs,
								..
							} => htlc_outputs.iter().any(|(_, source)| {
								source.as_ref().map(|s| &**s) == Some(&htlc.source)
							}),
							_ => continue,
						};
						debug_assert!(have_htlc);
						if have_htlc {
							dropped_outbound_htlcs.push((
								htlc.source.clone(),
								htlc.payment_hash,
								counterparty_node_id,
								self.channel_id,
							));
						}
						continue 'htlc_iter;
					}
				}
			}
		}

		let monitor_update = if let Some(funding_txo) = funding.get_funding_txo() {
			// We should only generate a closing `ChannelMonitorUpdate` if we already have a
			// `ChannelMonitor` for the disk (i.e. `counterparty_next_commitment_transaction_number`
			// has been decremented once, which hapens when we generate the initial
			// `ChannelMonitor`).  Otherwise, that would imply a channel monitor update before we
			// even registered the channel monitor to begin with, which is invalid.
			if self.counterparty_next_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
				self.latest_monitor_update_id = self.get_latest_unblocked_monitor_update_id() + 1;

				// HTLC failures are held until the `ChannelMonitorUpdate` for the counterparty's
				// `revoke_and_ack` completes. As they can no longer be released, hand them to the
				// `ChannelMonitor` to fail. It may already have been given the revocation, in
				// which case it no longer tracks the HTLCs and wouldn't resolve them otherwise.
				let counterparty_failed_htlcs = self
					.monitor_pending_failures
					.drain(..)
					.map(|(source, payment_hash, _)| (source, payment_hash))
					.collect();
				let update = ChannelMonitorUpdate {
					update_id: self.latest_monitor_update_id,
					updates: vec![ChannelMonitorUpdateStep::ChannelForceClosed {
						should_broadcast: broadcast,
						counterparty_failed_htlcs,
					}],
					channel_id: Some(self.channel_id()),
				};
				Some((self.get_counterparty_node_id(), funding_txo, self.channel_id(), update))
			} else {
				None
			}
		} else {
			None
		};
		let unbroadcasted_batch_funding_txid = self.unbroadcasted_batch_funding_txid(funding);
		let unbroadcasted_funding_tx = self.unbroadcasted_funding(funding);

		if let ClosureReason::HolderForceClosed { ref mut broadcasted_latest_txn, .. } =
			&mut closure_reason
		{
			*broadcasted_latest_txn = Some(broadcast);
		}

		self.channel_state = ChannelState::ShutdownComplete;
		self.update_time_counter += 1;
		ShutdownResult {
			closure_reason,
			monitor_update,
			dropped_outbound_htlcs,
			unbroadcasted_batch_funding_txid,
			channel_id: self.channel_id,
			user_channel_id: self.user_id,
			channel_capacity_satoshis: funding.get_value_satoshis(),
			counterparty_node_id: self.counterparty_node_id,
			unbroadcasted_funding_tx,
			is_manual_broadcast: self.is_manual_broadcast,
			channel_funding_txo: funding.get_funding_txo(),
			last_local_balance_msat: funding.value_to_self_msat,
			splice_funding_failed: Vec::new(),
			splice_funding_negotiated: None,
		}
	}

	/// Only allowed after [`FundingScope::channel_transaction_parameters`] is set.
	#[rustfmt::skip]
	fn get_funding_signed_msg<L: Logger>(
		&mut self, channel_parameters: &ChannelTransactionParameters, logger: &L,
		counterparty_initial_commitment_tx: CommitmentTransaction,
	) -> Option<msgs::FundingSigned> {
		let counterparty_trusted_tx = counterparty_initial_commitment_tx.trust();
		let counterparty_initial_bitcoin_tx = counterparty_trusted_tx.built_transaction();
		log_trace!(logger, "Initial counterparty tx for channel {} is: txid {} tx {}",
			&self.channel_id(), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));

		// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
		let signature = self
			.holder_signer
			.sign_counterparty_commitment(
				channel_parameters,
				&counterparty_initial_commitment_tx,
				Vec::new(),
				Vec::new(),
				&self.secp_ctx,
			)
			.ok();

		if signature.is_some() && self.signer_pending_funding {
			log_trace!(logger, "Counterparty commitment signature available for funding_signed message; clearing signer_pending_funding");
			self.signer_pending_funding = false;
		} else if signature.is_none() {
			log_trace!(logger, "Counterparty commitment signature not available for funding_signed message; setting signer_pending_funding");
			self.signer_pending_funding = true;
		}

		signature.map(|(signature, _)| msgs::FundingSigned {
			channel_id: self.channel_id(),
			signature,
		})
	}

	/// If we receive an error message when attempting to open a channel, it may only be a rejection
	/// of the channel type we tried, not of our ability to open any channel at all. We can see if a
	/// downgrade of channel features would be possible so that we can still open the channel.
	pub(crate) fn maybe_downgrade_channel_features<F: FeeEstimator>(
		&mut self, funding: &mut FundingScope, fee_estimator: &LowerBoundedFeeEstimator<F>,
		user_config: &UserConfig, their_features: &InitFeatures,
	) -> Result<(), ()> {
		if !funding.is_outbound()
			|| !matches!(
				self.channel_state, ChannelState::NegotiatingFunding(flags)
				if flags == NegotiatingFundingFlags::OUR_INIT_SENT
			) {
			return Err(());
		}
		if funding.get_channel_type() == &ChannelTypeFeatures::only_static_remote_key() {
			// We've exhausted our options
			return Err(());
		}

		// We should never have negotiated `anchors_nonzero_fee_htlc_tx` because it can result in a
		// loss of funds.
		let channel_type = &funding.channel_transaction_parameters.channel_type_features;
		assert!(!channel_type.supports_anchors_nonzero_fee_htlc_tx());

		// We support opening a few different types of channels. Try removing our additional
		// features one by one until we've either arrived at our default or the counterparty has
		// accepted one. Features are un-set for the current channel type or any that come before
		// it in our order of preference, allowing us to negotiate the "next best" based on the
		// counterparty's remaining features per our ranking in `get_initial_channel_type`.
		let mut eligible_features = their_features.clone();
		if channel_type.supports_anchor_zero_fee_commitments() {
			eligible_features.clear_anchor_zero_fee_commitments();
		} else if channel_type.supports_anchors_zero_fee_htlc_tx() {
			eligible_features.clear_anchor_zero_fee_commitments();
			eligible_features.clear_anchors_zero_fee_htlc_tx();
		} else if channel_type.supports_scid_privacy() {
			eligible_features.clear_scid_privacy();
			eligible_features.clear_anchors_zero_fee_htlc_tx();
			eligible_features.clear_anchor_zero_fee_commitments();
		}

		let next_channel_type = get_initial_channel_type(user_config, &eligible_features);
		if !next_channel_type.supports_anchors_zero_fee_htlc_tx()
			&& !next_channel_type.supports_anchor_zero_fee_commitments()
			&& funding.holder_selected_channel_reserve_satoshis == 0
		{
			// 0-reserve is not allowed on legacy channels
			return Err(());
		}

		self.feerate_per_kw =
			selected_commitment_sat_per_1000_weight(&fee_estimator, &next_channel_type);
		funding.channel_transaction_parameters.channel_type_features = next_channel_type;

		Ok(())
	}

	/// Asserts that the commitment tx numbers have not advanced from their initial number.
	fn assert_no_commitment_advancement(
		&self, holder_commitment_transaction_number: u64, msg_name: &str,
	) {
		if self.commitment_secrets.get_min_seen_secret() != (1 << 48)
			|| self.counterparty_next_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER
			|| holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER
		{
			debug_assert!(
				false,
				"Should not have advanced channel commitment tx numbers prior to {}",
				msg_name
			);
		}
	}

	fn get_initial_counterparty_commitment_signatures<L: Logger>(
		&self, funding: &FundingScope, logger: &L,
	) -> Option<(Signature, Vec<Signature>)> {
		let mut commitment_number = self.counterparty_next_commitment_transaction_number;
		let mut commitment_point = self.counterparty_next_commitment_point.unwrap();

		// Use the previous commitment number and point when splicing since they shouldn't change.
		if commitment_number != INITIAL_COMMITMENT_NUMBER {
			commitment_number += 1;
			commitment_point = self.counterparty_current_commitment_point.unwrap();
		}

		let commitment_data = self.build_commitment_transaction(
			funding,
			commitment_number,
			&commitment_point,
			false,
			true,
			logger,
		);
		let counterparty_initial_commitment_tx = commitment_data.tx;
		let channel_parameters = &funding.channel_transaction_parameters;
		self.holder_signer
			.sign_counterparty_commitment(
				channel_parameters,
				&counterparty_initial_commitment_tx,
				Vec::new(),
				Vec::new(),
				&self.secp_ctx,
			)
			.ok()
	}

	fn get_initial_commitment_signed_v2<L: Logger>(
		&mut self, funding: &FundingScope, logger: &L,
	) -> Option<msgs::CommitmentSigned> {
		let signatures = self.get_initial_counterparty_commitment_signatures(funding, logger);
		if let Some((signature, htlc_signatures)) = signatures {
			log_info!(logger, "Generated commitment_signed for peer",);
			if matches!(self.channel_state, ChannelState::FundingNegotiated(_)) {
				// We shouldn't expect any HTLCs before `ChannelReady`.
				debug_assert!(htlc_signatures.is_empty());
			}
			self.signer_pending_funding = false;
			Some(msgs::CommitmentSigned {
				channel_id: self.channel_id,
				htlc_signatures,
				signature,
				funding_txid: funding.get_funding_txo().map(|funding_txo| funding_txo.txid),
			})
		} else {
			log_debug!(
				logger,
				"Initial counterparty commitment signature not available, waiting on async signer"
			);
			self.signer_pending_funding = true;
			None
		}
	}

	fn check_funding_meets_minimum_depth(&self, funding: &FundingScope, height: u32) -> bool {
		let minimum_depth = self
			.minimum_depth(funding)
			.expect("ChannelContext::minimum_depth should be set for FundedChannel");

		// Zero-conf channels always meet the minimum depth.
		if minimum_depth == 0 {
			return true;
		}

		if funding.funding_tx_confirmation_height == 0 {
			return false;
		}

		let funding_tx_confirmations =
			height as i64 - funding.funding_tx_confirmation_height as i64 + 1;
		if funding_tx_confirmations < minimum_depth as i64 {
			return false;
		}

		return true;
	}

	#[rustfmt::skip]
	fn check_for_funding_tx_confirmed<L: Logger>(
		&mut self, funding: &mut FundingScope, block_hash: &BlockHash, height: u32,
		index_in_block: usize, tx: &mut ConfirmedTransaction, logger: &L,
	) -> Result<bool, ClosureReason> {
		let funding_txo = match funding.get_funding_txo() {
			Some(funding_txo) => funding_txo,
			None => {
				debug_assert!(false);
				return Ok(false);
			},
		};

		// Check if the transaction is the expected funding transaction, and if it is,
		// check that it pays the right amount to the right script.
		if funding.funding_tx_confirmation_height == 0 {
			if tx.txid() == funding_txo.txid {
				let tx = tx.tx();
				let txo_idx = funding_txo.index as usize;
				if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != funding.get_funding_redeemscript().to_p2wsh() ||
						tx.output[txo_idx].value.to_sat() != funding.get_value_satoshis() {
					if funding.is_outbound() {
						// If we generated the funding transaction and it doesn't match what it
						// should, the client is really broken and we should just panic and
						// tell them off. That said, because hash collisions happen with high
						// probability in fuzzing mode, if we're fuzzing we just close the
						// channel and move on.
						#[cfg(not(fuzzing))]
						panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
					}
					self.update_time_counter += 1;
					let err_reason = "funding tx had wrong script/value or output index";
					return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
				} else {
					if funding.is_outbound() {
						if !tx.is_coinbase() {
							for input in tx.input.iter() {
								if input.witness.is_empty() {
									// We generated a malleable funding transaction, implying we've
									// just exposed ourselves to funds loss to our counterparty.
									#[cfg(not(fuzzing))]
									panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
								}
							}
						}
					}

					funding.funding_tx_confirmation_height = height;
					funding.funding_tx_confirmed_in = Some(*block_hash);
					funding.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
						Ok(scid) => Some(scid),
						Err(_) => panic!("Block was bogus - either height was > 16 million, had > 16 million transactions, or had > 65k outputs"),
					};

					log_info!(
						logger,
						"Funding txid {} confirmed in block {}",
						funding_txo.txid,

						block_hash,
					);

					return Ok(true);
				}
			}
		}

		Ok(false)
	}

	/// Returns SCIDs that have been associated with the channel's funding transactions.
	pub fn historical_scids(&self) -> &[u64] {
		&self.historical_scids[..]
	}
}

// Internal utility functions for channels

/// Returns the value to use for `holder_max_htlc_value_in_flight_msat` as a percentage of the
/// `channel_value_satoshis` in msat, set through
/// [`ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage`]
/// or [`ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage`]
/// depending on the value of [`ChannelHandshakeConfig::announce_for_forwarding`].
///
/// The effective percentage is lower bounded by 1% and upper bounded by 100%.
///
/// [`ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage`]: crate::util::config::ChannelHandshakeConfig::announced_channel_max_inbound_htlc_value_in_flight_percentage
/// [`ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage`]: crate::util::config::ChannelHandshakeConfig::unannounced_channel_max_inbound_htlc_value_in_flight_percentage
/// [`ChannelHandshakeConfig::announce_for_forwarding`]: crate::util::config::ChannelHandshakeConfig::announce_for_forwarding
fn get_holder_max_htlc_value_in_flight_msat(
	channel_value_satoshis: u64, is_announced_channel: bool, config: &ChannelHandshakeConfig,
) -> u64 {
	let config_setting = if is_announced_channel {
		config.announced_channel_max_inbound_htlc_value_in_flight_percentage
	} else {
		config.unannounced_channel_max_inbound_htlc_value_in_flight_percentage
	};
	let configured_percent = if config_setting < 1 {
		1
	} else if config_setting > 100 {
		100
	} else {
		config_setting as u64
	};
	channel_value_satoshis * 10 * configured_percent
}

/// This is for legacy reasons, present for forward-compatibility.
/// LDK versions older than 0.0.104 don't know how read/handle values other than the legacy
/// percentage from storage. Hence, we use this function to not persist legacy values of
/// `holder_max_htlc_value_in_flight_msat` for channels into storage.
fn get_legacy_default_holder_max_htlc_value_in_flight_msat(channel_value_satoshis: u64) -> u64 {
	channel_value_satoshis * 10 * MAX_IN_FLIGHT_PERCENT_LEGACY as u64
}

/// Returns a minimum channel reserve value the remote needs to maintain,
/// required by us according to the configured or default
/// [`ChannelHandshakeConfig::their_channel_reserve_proportional_millionths`]
///
/// Guaranteed to return a value no larger than channel_value_satoshis
///
/// This is used both for outbound and inbound channels and has lower bound
/// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS`, and the `dust_limit_satoshis` of
/// the counterparty.
///
/// Returns `Err` if `channel_value_satoshis` is smaller than
/// `MIN_THEIR_CHAN_RESERVE_SATOSHIS` or the `dust_limit_satoshis` of the
/// counterparty.
pub(crate) fn get_holder_selected_channel_reserve_satoshis(
	channel_value_satoshis: u64, their_dust_limit_satoshis: u64, config: &UserConfig,
	is_0reserve: bool,
) -> Result<u64, ()> {
	if channel_value_satoshis < MIN_THEIR_CHAN_RESERVE_SATOSHIS
		|| channel_value_satoshis < their_dust_limit_satoshis
	{
		return Err(());
	}
	if is_0reserve {
		return Ok(0);
	}
	// As described in the `ChannelHandshakeConfig` docs, we cap this value at 1_000_000.
	let counterparty_chan_reserve_prop_mil = cmp::min(
		config.channel_handshake_config.their_channel_reserve_proportional_millionths as u64,
		1_000_000,
	);
	let calculated_reserve =
		channel_value_satoshis.saturating_mul(counterparty_chan_reserve_prop_mil) / 1_000_000;
	let channel_reserve_satoshis = cmp::max(calculated_reserve, MIN_THEIR_CHAN_RESERVE_SATOSHIS);
	let channel_reserve_satoshis = cmp::max(channel_reserve_satoshis, their_dust_limit_satoshis);
	Ok(channel_reserve_satoshis)
}

/// This is for legacy reasons, present for forward-compatibility.
/// LDK versions older than 0.0.104 don't know how read/handle values other than default
/// from storage. Hence, we use this function to not persist default values of
/// `holder_selected_channel_reserve_satoshis` for channels into storage.
pub(crate) fn get_legacy_default_holder_selected_channel_reserve_satoshis(
	channel_value_satoshis: u64,
) -> u64 {
	let (q, _) = channel_value_satoshis.overflowing_div(100);
	cmp::min(channel_value_satoshis, cmp::max(q, 1000))
}

/// Returns a minimum channel reserve value each party needs to maintain, fixed in the spec to a
/// default of 1% of the total channel value.
///
/// Guaranteed to return a value no larger than `channel_value_satoshis`
///
/// This is used both for outbound and inbound channels and has lower bound
/// of `dust_limit_satoshis`.
///
/// Returns `Err` if `channel_value_satoshis` is smaller than `dust_limit_satoshis`.
pub(crate) fn get_v2_channel_reserve_satoshis(
	channel_value_satoshis: u64, dust_limit_satoshis: u64, is_0reserve: bool,
) -> Result<u64, ()> {
	if channel_value_satoshis < dust_limit_satoshis {
		return Err(());
	}
	if is_0reserve {
		return Ok(0);
	}
	// Fixed at 1% of channel value by spec.
	let (q, _) = channel_value_satoshis.overflowing_div(100);
	Ok(cmp::max(q, dust_limit_satoshis))
}

/// Context for negotiating channels (dual-funded V2 open, splicing)
#[derive(Debug)]
pub(super) struct FundingNegotiationContext {
	/// Whether we initiated the funding negotiation.
	pub is_initiator: bool,
	/// The amount in satoshis we will be contributing to the channel.
	pub our_funding_contribution: SignedAmount,
	/// The funding transaction locktime suggested by the initiator. If set by us, it is always set
	/// to the current block height to align incentives against fee-sniping.
	pub funding_tx_locktime: LockTime,
	/// The feerate set by the initiator to be used for the funding transaction.
	#[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
	pub funding_feerate_sat_per_1000_weight: u32,
	/// The input spending the previous funding output, if this is a splice.
	#[allow(dead_code)] // TODO(splicing): Remove once splicing is enabled.
	pub shared_funding_input: Option<SharedOwnedInput>,
	/// The funding inputs we will be contributing to the channel.
	#[allow(dead_code)] // TODO(dual_funding): Remove once contribution to V2 channels is enabled.
	pub our_funding_inputs: Vec<ConfirmedUtxo>,
	/// The funding outputs we will be contributing to the channel.
	#[allow(dead_code)] // TODO(dual_funding): Remove once contribution to V2 channels is enabled.
	pub our_funding_outputs: Vec<TxOut>,
}

impl FundingNegotiationContext {
	/// Prepare and start interactive transaction negotiation.
	/// If error occurs, it is caused by our side, not the counterparty.
	fn into_interactive_tx_constructor<SP: SignerProvider, ES: EntropySource>(
		self, context: &ChannelContext<SP>, funding: &FundingScope, entropy_source: &ES,
		holder_node_id: PublicKey,
	) -> (InteractiveTxConstructor, Option<InteractiveTxMessageSend>) {
		debug_assert_eq!(
			self.shared_funding_input.is_some(),
			funding.channel_transaction_parameters.splice_parent_funding_txid.is_some(),
		);

		if self.shared_funding_input.is_some() {
			debug_assert!(matches!(context.channel_state, ChannelState::ChannelReady(_)));
		} else {
			debug_assert!(matches!(context.channel_state, ChannelState::NegotiatingFunding(_)));
		}

		let shared_funding_output = TxOut {
			value: Amount::from_sat(funding.get_value_satoshis()),
			script_pubkey: funding.get_funding_redeemscript().to_p2wsh(),
		};

		let constructor_args = InteractiveTxConstructorArgs {
			entropy_source,
			holder_node_id,
			counterparty_node_id: context.counterparty_node_id,
			channel_id: context.channel_id(),
			feerate_sat_per_kw: self.funding_feerate_sat_per_1000_weight,
			funding_tx_locktime: self.funding_tx_locktime,
			inputs_to_contribute: self.our_funding_inputs,
			shared_funding_input: self.shared_funding_input,
			shared_funding_output: SharedOwnedOutput::new(
				shared_funding_output,
				funding.value_to_self_msat / 1000,
			),
			outputs_to_contribute: self.our_funding_outputs,
		};
		if self.is_initiator {
			InteractiveTxConstructor::new_for_outbound(constructor_args)
		} else {
			(InteractiveTxConstructor::new_for_inbound(constructor_args), None)
		}
	}

	fn contributed_inputs(&self) -> impl Iterator<Item = bitcoin::OutPoint> + '_ {
		self.our_funding_inputs.iter().map(|input| input.utxo.outpoint)
	}

	fn contributed_outputs(&self) -> impl Iterator<Item = &bitcoin::Script> + '_ {
		self.our_funding_outputs.iter().map(|output| output.script_pubkey.as_script())
	}
}

// Holder designates channel data owned for the benefit of the user client.
// Counterparty designates channel data owned by the another channel participant entity.
#[cfg_attr(test, derive(Debug))]
pub(super) struct FundedChannel<SP: SignerProvider> {
	pub funding: FundingScope,
	pub context: ChannelContext<SP>,
	holder_commitment_point: HolderCommitmentPoint,

	/// Information about any pending splice candidates, including RBF attempts.
	pending_splice: Option<PendingFunding>,

	/// Once we become quiescent, if we're the initiator, there's some action we'll want to take.
	/// This keeps track of that action. Note that if we become quiescent and we're not the
	/// initiator we may be able to merge this action into what the counterparty wanted to do (e.g.
	/// in the case of splicing).
	quiescent_action: Option<QuiescentAction>,
}

#[cfg(any(test, fuzzing))]
#[derive(Clone, Copy, Default, Debug)]
struct PredictedNextFee {
	predicted_feerate: u32,
	predicted_nondust_htlc_count: usize,
	predicted_fee_sat: u64,
}

/// Contents of a wire message that fails an HTLC backwards. Useful for [`FundedChannel::fail_htlc`] to
/// fail with either [`msgs::UpdateFailMalformedHTLC`] or [`msgs::UpdateFailHTLC`] as needed.
trait FailHTLCContents {
	type Message: FailHTLCMessageName;
	fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message;
	fn to_inbound_htlc_state(self) -> InboundHTLCState;
	fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK;
}
impl FailHTLCContents for msgs::OnionErrorPacket {
	type Message = msgs::UpdateFailHTLC;
	fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message {
		msgs::UpdateFailHTLC {
			htlc_id,
			channel_id,
			reason: self.data,
			attribution_data: self.attribution_data,
		}
	}
	fn to_inbound_htlc_state(self) -> InboundHTLCState {
		InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(self))
	}
	fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK {
		HTLCUpdateAwaitingACK::FailHTLC { htlc_id, err_packet: self }
	}
}
impl FailHTLCContents for ([u8; 32], u16) {
	type Message = msgs::UpdateFailMalformedHTLC;
	fn to_message(self, htlc_id: u64, channel_id: ChannelId) -> Self::Message {
		msgs::UpdateFailMalformedHTLC {
			htlc_id,
			channel_id,
			sha256_of_onion: self.0,
			failure_code: self.1,
		}
	}
	fn to_inbound_htlc_state(self) -> InboundHTLCState {
		InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailMalformed {
			sha256_of_onion: self.0,
			failure_code: self.1,
		})
	}
	fn to_htlc_update_awaiting_ack(self, htlc_id: u64) -> HTLCUpdateAwaitingACK {
		HTLCUpdateAwaitingACK::FailMalformedHTLC {
			htlc_id,
			sha256_of_onion: self.0,
			failure_code: self.1,
		}
	}
}

trait FailHTLCMessageName {
	fn name() -> &'static str;
}
impl FailHTLCMessageName for msgs::UpdateFailHTLC {
	fn name() -> &'static str {
		"update_fail_htlc"
	}
}
impl FailHTLCMessageName for msgs::UpdateFailMalformedHTLC {
	fn name() -> &'static str {
		"update_fail_malformed_htlc"
	}
}

type BestBlockUpdatedRes = (
	Option<FundingConfirmedMessage>,
	Vec<(HTLCSource, PaymentHash)>,
	Option<msgs::AnnouncementSignatures>,
	Option<SpliceRbfAbort>,
);

/// The result of handling a `tx_complete` message during interactive transaction construction.
pub(super) struct TxCompleteResult {
	/// The message to send to the counterparty, if any.
	pub interactive_tx_msg_send: Option<InteractiveTxMessageSend>,

	/// If the negotiation completed and the holder has local contributions, this contains the
	/// unsigned funding transaction for the `FundingTransactionReadyForSigning` event.
	pub event_unsigned_tx: Option<Transaction>,

	/// If the negotiation completed and the holder has no local contributions, this contains
	/// the result of automatically calling `funding_transaction_signed` with empty witnesses.
	pub funding_tx_signed: Option<FundingTxSigned>,
}

/// The result of signing a funding transaction negotiated using the interactive-tx protocol.
#[derive(Default)]
pub(super) struct FundingTxSigned {
	/// The initial `commitment_signed` message to send to the counterparty, if necessary.
	pub commitment_signed: Option<msgs::CommitmentSigned>,

	/// The result of processing a buffered initial commitment signed from our counterparty,
	/// if any.
	pub counterparty_initial_commitment_signed_result:
		Option<Result<Option<ChannelMonitorUpdate>, ChannelError>>,

	/// Signatures that should be sent to the counterparty, if necessary.
	pub tx_signatures: Option<msgs::TxSignatures>,

	/// The fully-signed funding transaction to be broadcast, along with the transaction type.
	pub funding_tx: Option<(Transaction, TransactionType)>,

	/// Information about the completed funding negotiation.
	pub splice_negotiated: Option<SpliceFundingNegotiated>,

	/// A `splice_locked` to send to the counterparty when the splice requires 0 confirmations.
	pub splice_locked: Option<msgs::SpliceLocked>,
}

/// Information about a splice funding negotiation that has been completed.
pub struct SpliceFundingNegotiated {
	/// The outpoint of the channel's splice funding transaction.
	pub funding_txo: bitcoin::OutPoint,

	/// Whether the holder contributed local inputs or outputs to the negotiated splice.
	pub has_local_contribution: bool,

	/// The features that this channel will operate with.
	pub channel_type: ChannelTypeFeatures,

	/// The redeem script of the funding output.
	pub funding_redeem_script: ScriptBuf,
}

/// Information about a splice funding negotiation that has failed.
pub struct SpliceFundingFailed {
	/// UTXOs released by the failure. Excludes inputs the contribution recorded as committed to
	/// another splice attempt, which may still be included in `contribution`.
	contributed_inputs: Vec<bitcoin::OutPoint>,

	/// Outputs released by the failure. Excludes outputs the contribution recorded as committed to
	/// another splice attempt, which may still be included in `contribution`.
	contributed_outputs: Vec<TxOut>,

	/// The funding contribution from the failed round.
	contribution: FundingContribution,
}

/// Information about an active RBF negotiation aborted after a prior splice candidate confirmed.
pub(super) struct SpliceRbfAbort {
	pub tx_abort: msgs::TxAbort,
	pub splice_funding_failed: Option<SpliceFundingFailed>,
}

impl SpliceFundingFailed {
	/// Builds a failure for `contribution` that releases its [`FundingContribution::reserved_inputs`]
	/// and [`FundingContribution::reserved_outputs`]. Inputs and outputs it inherited from a pending
	/// splice attempt are not released, as that attempt's transaction may still confirm.
	fn from_contribution(contribution: FundingContribution) -> Self {
		let (contributed_inputs, contributed_outputs) = contribution
			.unique_contributions()
			.map(|(inputs, outputs)| (inputs, outputs.into_iter().cloned().collect()))
			.unwrap_or_default();
		Self { contributed_inputs, contributed_outputs, contribution }
	}

	/// Splits into the funding info for `DiscardFunding` (if there are inputs or outputs to
	/// discard) and the contribution for `SpliceNegotiationFailed`.
	pub(super) fn into_parts(self) -> (Option<FundingInfo>, FailedSpliceContribution) {
		let funding_info = FundingInfo::contribution(
			self.contributed_inputs.clone(),
			self.contributed_outputs.iter().map(|output| output.script_pubkey.clone()).collect(),
		);
		let contribution = FailedSpliceContribution::new(
			self.contributed_inputs,
			self.contributed_outputs,
			self.contribution,
		);
		(funding_info, contribution)
	}
}

pub struct SpliceFundingPromotion {
	pub funding_txo: OutPoint,
	pub monitor_update: Option<ChannelMonitorUpdate>,
	pub announcement_sigs: Option<msgs::AnnouncementSignatures>,
	pub discarded_funding: Vec<FundingInfo>,
	pub splice_funding_failed: Option<SpliceFundingFailed>,
}

impl<SP: SignerProvider> FundedChannel<SP>
where
	SP::EcdsaSigner: EcdsaChannelSigner,
{
	pub fn context(&self) -> &ChannelContext<SP> {
		&self.context
	}

	pub fn force_shutdown(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
		let (splice_funding_failed, splice_funding_negotiated) =
			self.resolve_pending_splice_on_close();

		let mut shutdown_result = self.context.force_shutdown(&self.funding, closure_reason);
		shutdown_result.splice_funding_failed = splice_funding_failed;
		shutdown_result.splice_funding_negotiated = splice_funding_negotiated;
		shutdown_result
	}

	fn abandon_quiescent_action(&mut self) -> Option<SpliceFundingFailed> {
		match self.quiescent_action.take()? {
			QuiescentAction::Splice { contribution, .. } => {
				Some(SpliceFundingFailed::from_contribution(contribution))
			},
			#[cfg(any(test, fuzzing, feature = "_test_utils"))]
			QuiescentAction::DoNothing => None,
		}
	}

	fn resolve_pending_splice_on_close(
		&mut self,
	) -> (Vec<SpliceFundingFailed>, Option<SpliceFundingNegotiated>) {
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return (Vec::new(), None);
		}
		// A contribution queued for a later round (e.g., behind a counterparty-initiated
		// negotiation) fails independently of the active round and must also be reported.
		let queued_failed = self.abandon_quiescent_action();
		let (negotiation_failed, splice_funding_negotiated) = self.reset_pending_splice_state();
		let splice_funding_failed = negotiation_failed.into_iter().chain(queued_failed).collect();
		(splice_funding_failed, splice_funding_negotiated)
	}

	fn interactive_tx_constructor_mut(&mut self) -> Option<&mut InteractiveTxConstructor> {
		self.pending_splice
			.as_mut()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_mut())
			.and_then(|funding_negotiation| {
				if let FundingNegotiation::ConstructingTransaction {
					interactive_tx_constructor,
					..
				} = funding_negotiation
				{
					Some(interactive_tx_constructor)
				} else {
					None
				}
			})
	}

	fn negotiated_candidates(&self) -> &[NegotiatedCandidate] {
		self.pending_splice
			.as_ref()
			.map(|pending_splice| pending_splice.negotiated_candidates.as_slice())
			.unwrap_or(&[])
	}

	fn pending_funding(&self) -> impl ExactSizeIterator<Item = &FundingScope> + '_ {
		self.negotiated_candidates().iter().map(|candidate| &candidate.funding)
	}

	fn funding_and_pending_funding_iter_mut(&mut self) -> impl Iterator<Item = &mut FundingScope> {
		core::iter::once(&mut self.funding).chain(
			self.pending_splice
				.as_mut()
				.map(|pending_splice| pending_splice.negotiated_candidates.as_mut_slice())
				.unwrap_or(&mut [])
				.iter_mut()
				.map(|candidate| &mut candidate.funding),
		)
	}

	/// Returns details about any pending splice attempts for inclusion in
	/// [`crate::ln::channel_state::ChannelDetails`].
	pub fn pending_splice_details(&self, best_block_height: u32) -> Option<SpliceDetails> {
		let mut details = self
			.pending_splice
			.as_ref()
			.map(|pending_splice| pending_splice.to_details(&self.context, best_block_height));

		// A contribution committed via `funding_contributed` sits in `quiescent_action` until
		// quiescence is reached and it begins negotiating; surface it as the last candidate, in a
		// `WaitingOn*` status describing what it is waiting on.
		if let Some(contribution) = self.queued_funding_contribution() {
			// It begins negotiating at the next quiescence if there is no pending candidate or it can
			// replace one via RBF; otherwise its outcome must wait for the pending candidate to lock.
			// It can then proceed as a fresh splice only if it does not reuse any inputs or outputs
			// from the promote splice transaction.
			let status = if self.pending_splice.is_none()
				|| self.queued_contribution_can_rbf(contribution)
			{
				SpliceCandidateStatus::WaitingOnQuiescence
			} else {
				SpliceCandidateStatus::WaitingOnLock
			};
			let candidate =
				SpliceCandidateDetails { contribution: Some(contribution.clone()), status };
			match &mut details {
				Some(details) => details.candidates.push(candidate),
				// No `PendingFunding` yet (a first splice still awaiting quiescence), but the queued
				// contribution is still worth surfacing.
				None => {
					details = Some(SpliceDetails {
						candidates: vec![candidate],
						confirmed_candidate: None,
						received_splice_locked_txid: None,
					});
				},
			}
		}

		details
	}

	fn has_pending_splice_awaiting_signatures(&self) -> bool {
		self.pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
			.map(|funding_negotiation| {
				matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures { .. })
			})
			.unwrap_or(false)
	}

	/// Returns a boolean indicating whether we should reset the splice's
	/// [`PendingFunding::funding_negotiation`].
	fn should_reset_pending_splice_state(&self, allow_resumption: bool) -> bool {
		self.pending_splice
			.as_ref()
			.map(|pending_splice| {
				pending_splice
					.funding_negotiation
					.as_ref()
					.map(|funding_negotiation| {
						let is_awaiting_signatures = matches!(
							funding_negotiation,
							FundingNegotiation::AwaitingSignatures { .. }
						);
						if allow_resumption {
							// If we want to resume the negotiation after reconnecting, we must be
							// in [`FundingNegotiation::AwaitingSignatures`] to not reset our state.
							!is_awaiting_signatures
						} else {
							!is_awaiting_signatures
								|| !self
									.context()
									.interactive_tx_signing_session
									.as_ref()
									.expect("We have a pending splice awaiting signatures")
									.has_received_commitment_signed()
						}
					})
					.unwrap_or_else(|| {
						let has_negotiated_candidates =
							!pending_splice.negotiated_candidates.is_empty();
						debug_assert!(has_negotiated_candidates);
						!has_negotiated_candidates
					})
			})
			.unwrap_or(false)
	}

	/// Resets splice negotiation and quiescence state, returning a failed local contribution or
	/// a pending splice whose funding signatures are ready to send.
	fn reset_pending_splice_state(
		&mut self,
	) -> (Option<SpliceFundingFailed>, Option<SpliceFundingNegotiated>) {
		let funding_negotiation = self
			.pending_splice
			.as_mut()
			.and_then(|pending_splice| pending_splice.funding_negotiation.take());

		let (counterparty_committed, splice_funding_negotiated) = match funding_negotiation.as_ref()
		{
			Some(FundingNegotiation::AwaitingSignatures { funding, .. }) => {
				let signing_session = self
					.context
					.interactive_tx_signing_session
					.as_ref()
					.expect("We have a pending splice awaiting signatures");
				let splice_funding_negotiated =
					signing_session.holder_tx_signatures().map(|_| SpliceFundingNegotiated {
						funding_txo: funding
							.get_funding_txo()
							.expect("Negotiated funding has an outpoint")
							.into_bitcoin_outpoint(),
						has_local_contribution: signing_session.has_local_contribution(),
						channel_type: funding.get_channel_type().clone(),
						funding_redeem_script: funding.get_funding_redeemscript(),
					});
				(signing_session.has_received_commitment_signed(), splice_funding_negotiated)
			},
			_ => (false, None),
		};
		let splice_funding_failed =
			if funding_negotiation.is_some() && splice_funding_negotiated.is_none() {
				self.pending_splice.as_mut().and_then(|pending_splice| {
					if let Some(ref contribution) = pending_splice.negotiation_contribution {
						debug_assert!(
						pending_splice
							.last_funding_feerate_sat_per_1000_weight
							.map(|f| contribution.feerate() > FeeRate::from_sat_per_kwu(f as u64))
							.unwrap_or(true),
						"current round's feerate should be greater than the last negotiated feerate",
					);
					}
					pending_splice.negotiation_contribution.take().map(|contribution| {
						if counterparty_committed {
							// Committed funding remains reserved until the closing transaction has
							// enough confirmations to safely discard it.
							SpliceFundingFailed {
								contributed_inputs: Vec::new(),
								contributed_outputs: Vec::new(),
								contribution,
							}
						} else {
							SpliceFundingFailed::from_contribution(contribution)
						}
					})
				})
			} else {
				None
			};

		if self.negotiated_candidates().is_empty() {
			self.pending_splice.take();
		}
		if funding_negotiation.is_some() {
			self.exit_quiescence();
		}
		if matches!(funding_negotiation, Some(FundingNegotiation::AwaitingSignatures { .. })) {
			// Only clear the signing session if the current round is mid-signing. When an earlier
			// round completed signing and a later RBF round is in `AwaitingAck` or
			// `ConstructingTransaction`, the session belongs to the prior round and must be
			// preserved.
			self.context.interactive_tx_signing_session.take();
			self.context.signer_pending_funding = false;
		}

		(splice_funding_failed, splice_funding_negotiated)
	}

	fn abort_ongoing_rbf_after_splice_confirmation<L: Logger>(
		&mut self, logger: &L,
	) -> Option<SpliceRbfAbort> {
		let has_ongoing_rbf = self
			.pending_splice
			.as_ref()
			.map(|pending_splice| {
				pending_splice.has_confirmed_candidate()
					&& pending_splice.funding_negotiation.is_some()
			})
			.unwrap_or(false);
		if !has_ongoing_rbf {
			return None;
		}

		// Before the current round reaches AwaitingSignatures, the retained signing session belongs
		// to the prior candidate and must not prevent aborting the new RBF.
		let has_provided_funding_signatures = self.has_pending_splice_awaiting_signatures()
			&& self
				.context
				.interactive_tx_signing_session
				.as_ref()
				.map(|signing_session| signing_session.has_holder_witnesses())
				.unwrap_or(false);
		if has_provided_funding_signatures {
			// Once signing has advanced this far, leave the negotiation active and allow the
			// signature exchange to continue. If the confirmed candidate reaches lock-in first,
			// normal promotion will discard the conflicting RBF attempt.
			debug_assert!(!self.should_reset_pending_splice_state(true));
			log_debug!(
				logger,
				"Continuing an RBF negotiation after another splice candidate confirmed because signing has advanced too far to abort safely",
			);
			return None;
		}

		log_info!(logger, "Aborting an active RBF negotiation after a splice candidate confirmed");
		let (splice_funding_failed, splice_funding_negotiated) = self.reset_pending_splice_state();
		debug_assert!(splice_funding_negotiated.is_none());
		let tx_abort =
			AbortReason::RbfUnavailable("A negotiated splice candidate has confirmed".to_owned())
				.into_tx_abort_msg(self.context.channel_id());
		Some(SpliceRbfAbort { tx_abort, splice_funding_failed })
	}

	/// Returns a [`SpliceFundingFailed`] for each splice contribution which a restart drops
	/// because it is not persisted: one in a funding negotiation which is not written, and one
	/// still queued waiting on quiescence.
	pub(super) fn on_restart_splice_failures(&self) -> impl Iterator<Item = SpliceFundingFailed> {
		let mut negotiation_failure = None;
		if self.should_reset_pending_splice_state(true) {
			let pending_splice = self
				.pending_splice
				.as_ref()
				.expect("should_reset_pending_splice_state requires pending_splice");
			debug_assert!(
				pending_splice.funding_negotiation.is_some(),
				"a pending splice to reset requires an active funding negotiation"
			);
			negotiation_failure = pending_splice
				.negotiation_contribution
				.clone()
				.map(SpliceFundingFailed::from_contribution);
		}

		// A contribution queued for a later round (e.g., behind a counterparty-initiated
		// negotiation) fails independently of the active round and must also be reported.
		let queued_failure =
			self.queued_funding_contribution().cloned().map(SpliceFundingFailed::from_contribution);

		negotiation_failure.into_iter().chain(queued_failure)
	}

	#[rustfmt::skip]
	fn check_remote_fee<F: FeeEstimator, L: Logger>(
		channel_type: &ChannelTypeFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,
		feerate_per_kw: u32, cur_feerate_per_kw: Option<u32>, logger: &L
	) -> Result<(), ChannelError> {
		if channel_type.supports_anchor_zero_fee_commitments() {
			if feerate_per_kw != 0 {
				let err = "Zero Fee Channels must never attempt to use a fee".to_owned();
				return Err(ChannelError::close(err));
			} else {
				return Ok(());
			}
		}

		let lower_limit_conf_target = if channel_type.supports_anchors_zero_fee_htlc_tx() {
			ConfirmationTarget::MinAllowedAnchorChannelRemoteFee
		} else {
			ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee
		};
		let lower_limit = fee_estimator.bounded_sat_per_1000_weight(lower_limit_conf_target);
		if feerate_per_kw < lower_limit {
			if let Some(cur_feerate) = cur_feerate_per_kw {
				if feerate_per_kw > cur_feerate {
					log_warn!(logger,
						"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.",
						cur_feerate, feerate_per_kw);
					return Ok(());
				}
			}
			return Err(ChannelError::Close((format!(
				"Peer's feerate much too low. Actual: {}. Our expected lower limit: {}", feerate_per_kw, lower_limit
			), ClosureReason::PeerFeerateTooLow {
				peer_feerate_sat_per_kw: feerate_per_kw,
				required_feerate_sat_per_kw: lower_limit,
			})));
		}
		Ok(())
	}

	#[inline]
	fn get_closing_scriptpubkey(&self) -> ScriptBuf {
		// The shutdown scriptpubkey is set on channel opening when option_upfront_shutdown_script
		// is signaled. Otherwise, it is set when sending a shutdown message. Calling this method
		// outside of those situations will fail.
		self.context.shutdown_scriptpubkey.clone().unwrap().into_inner()
	}

	#[inline]
	fn get_closing_transaction_weight(
		&self, a_scriptpubkey: Option<&Script>, b_scriptpubkey: Option<&Script>,
	) -> u64 {
		let mut ret = (4 +                                                   // version
		 1 +                                                   // input count
		 36 +                                                  // prevout
		 1 +                                                   // script length (0)
		 4 +                                                   // sequence
		 1 +                                                   // output count
		 4                                                     // lock time
		 )*4 +                                                 // * 4 for non-witness parts
		2 +                                                    // witness marker and flag
		1 +                                                    // witness element count
		4 +                                                    // 4 element lengths (2 sigs, multisig dummy, and witness script)
		self.funding.get_funding_redeemscript().len() as u64 + // funding witness script
		2*(1 + 71); // two signatures + sighash type flags
		if let Some(spk) = a_scriptpubkey {
			ret += ((8+1) +                                    // output values and script length
				spk.len() as u64)                              // scriptpubkey
				* 4; // witness multiplier
		}
		if let Some(spk) = b_scriptpubkey {
			ret += ((8+1) +                                    // output values and script length
				spk.len() as u64)                              // scriptpubkey
				* 4; // witness multiplier
		}
		ret
	}

	#[inline]
	fn build_closing_transaction(
		&self, proposed_total_fee_satoshis: u64, skip_remote_output: bool,
	) -> Result<(ClosingTransaction, u64), ChannelError> {
		assert!(self.context.pending_inbound_htlcs.is_empty());
		assert!(self.context.pending_outbound_htlcs.is_empty());
		assert!(self.context.pending_update_fee.is_none());

		let mut total_fee_satoshis = proposed_total_fee_satoshis;
		let mut value_to_holder: i64 = (self.funding.value_to_self_msat as i64) / 1000
			- if self.funding.is_outbound() { total_fee_satoshis as i64 } else { 0 };
		let mut value_to_counterparty: i64 =
			((self.funding.get_value_satoshis() * 1000 - self.funding.value_to_self_msat) as i64
				/ 1000) - if self.funding.is_outbound() { 0 } else { total_fee_satoshis as i64 };

		if value_to_holder < 0 {
			assert!(self.funding.is_outbound());
			total_fee_satoshis += (-value_to_holder) as u64;
		} else if value_to_counterparty < 0 {
			assert!(!self.funding.is_outbound());
			total_fee_satoshis += (-value_to_counterparty) as u64;
		}

		debug_assert!(value_to_counterparty >= 0);
		if value_to_counterparty < 0 {
			return Err(ChannelError::close(format!(
				"Value to counterparty below 0: {}",
				value_to_counterparty
			)));
		}
		if skip_remote_output
			|| value_to_counterparty as u64 <= self.context.holder_dust_limit_satoshis
		{
			value_to_counterparty = 0;
		}

		debug_assert!(value_to_holder >= 0);
		if value_to_holder < 0 {
			return Err(ChannelError::close(format!(
				"Value to holder below 0: {}",
				value_to_holder
			)));
		}
		if value_to_holder as u64 <= self.context.holder_dust_limit_satoshis {
			value_to_holder = 0;
		}

		assert!(self.context.shutdown_scriptpubkey.is_some());
		let holder_shutdown_script = self.get_closing_scriptpubkey();
		let counterparty_shutdown_script =
			self.context.counterparty_shutdown_scriptpubkey.clone().unwrap();
		let funding_outpoint = self.funding_outpoint().into_bitcoin_outpoint();

		let closing_transaction = ClosingTransaction::new(
			value_to_holder as u64,
			value_to_counterparty as u64,
			holder_shutdown_script,
			counterparty_shutdown_script,
			funding_outpoint,
		);
		Ok((closing_transaction, total_fee_satoshis))
	}

	pub fn funding_outpoint(&self) -> OutPoint {
		self.funding.channel_transaction_parameters.funding_outpoint.unwrap()
	}

	/// Claims an HTLC while we're disconnected from a peer, dropping the [`ChannelMonitorUpdate`]
	/// entirely.
	///
	/// This is only used for payments received prior to LDK 0.1.
	///
	/// The [`ChannelMonitor`] for this channel MUST be updated out-of-band with the preimage
	/// provided (i.e. without calling [`crate::chain::Watch::update_channel`]).
	///
	/// The HTLC claim will end up in the holding cell (because the caller must ensure the peer is
	/// disconnected).
	pub fn claim_htlc_while_disconnected_dropping_mon_update_legacy<L: Logger>(
		&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage, logger: &L,
	) {
		// Assert that we'll add the HTLC claim to the holding cell in `get_update_fulfill_htlc`
		// (see equivalent if condition there).
		assert!(!self.context.channel_state.can_generate_new_commitment());
		let mon_update_id = self.context.latest_monitor_update_id; // Forget the ChannelMonitor update
		let fulfill_resp =
			self.get_update_fulfill_htlc(htlc_id_arg, payment_preimage_arg, None, None, logger);
		self.context.latest_monitor_update_id = mon_update_id;
		if let UpdateFulfillFetch::NewClaim { update_blocked, .. } = fulfill_resp {
			assert!(update_blocked); // The HTLC must have ended up in the holding cell.
		}
	}

	fn get_update_fulfill_htlc<L: Logger>(
		&mut self, htlc_id_arg: u64, payment_preimage_arg: PaymentPreimage,
		payment_info: Option<PaymentClaimDetails>, attribution_data: Option<AttributionData>,
		logger: &L,
	) -> UpdateFulfillFetch {
		// Either ChannelReady got set (which means it won't be unset) or there is no way any
		// caller thought we could have something claimed (cause we wouldn't have accepted in an
		// incoming HTLC anyway). If we got to ShutdownComplete, callers aren't allowed to call us,
		// either.
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			panic!("Was asked to fulfill an HTLC when channel was not in an operational state");
		}

		// ChannelManager may generate duplicate claims/fails due to HTLC update events from
		// on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
		// these, but for now we just have to treat them as normal.

		let mut pending_idx = core::usize::MAX;
		let mut htlc_value_msat = 0;
		for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
			if htlc.htlc_id == htlc_id_arg {
				let expected_hash =
					PaymentHash(Sha256::hash(&payment_preimage_arg.0[..]).to_byte_array());
				debug_assert_eq!(htlc.payment_hash, expected_hash);
				log_debug!(
					logger,
					"Claiming inbound HTLC id {} with payment hash {} with preimage {}",
					htlc.htlc_id,
					htlc.payment_hash,
					payment_preimage_arg
				);
				match htlc.state {
					InboundHTLCState::Committed { .. } => {},
					InboundHTLCState::LocalRemoved(ref reason) => {
						if let &InboundHTLCRemovalReason::Fulfill { .. } = reason {
						} else {
							log_warn!(logger, "Have preimage and want to fulfill HTLC with payment hash {} we already failed against channel {}", &htlc.payment_hash, &self.context.channel_id());
							debug_assert!(
								false,
								"Tried to fulfill an HTLC that was already failed"
							);
						}
						return UpdateFulfillFetch::DuplicateClaim {};
					},
					_ => {
						debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
						// Don't return in release mode here so that we can update channel_monitor
					},
				}
				pending_idx = idx;
				htlc_value_msat = htlc.amount_msat;
				break;
			}
		}
		if pending_idx == core::usize::MAX {
			return UpdateFulfillFetch::DuplicateClaim {};
		}

		// Now update local state:
		//
		// We have to put the payment_preimage in the channel_monitor right away here to ensure we
		// can claim it even if the channel hits the chain before we see their next commitment.
		self.context.latest_monitor_update_id += 1;
		let monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![ChannelMonitorUpdateStep::PaymentPreimage {
				payment_preimage: payment_preimage_arg.clone(),
				payment_info,
			}],
			channel_id: Some(self.context.channel_id()),
		};

		if !self.context.channel_state.can_generate_new_commitment() {
			// Note that this condition is the same as the assertion in
			// `claim_htlc_while_disconnected_dropping_mon_update` and must match exactly -
			// `claim_htlc_while_disconnected_dropping_mon_update` would not work correctly if we
			// do not not get into this branch.
			for pending_update in self.context.holding_cell_htlc_updates.iter() {
				match pending_update {
					&HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
						if htlc_id_arg == htlc_id {
							// Make sure we don't leave latest_monitor_update_id incremented here:
							self.context.latest_monitor_update_id -= 1;
							return UpdateFulfillFetch::DuplicateClaim {};
						}
					},
					&HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. }
					| &HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } => {
						if htlc_id_arg == htlc_id {
							log_warn!(logger, "Have preimage and want to fulfill HTLC with pending failure against channel {}", &self.context.channel_id());
							// TODO: We may actually be able to switch to a fulfill here, though its
							// rare enough it may not be worth the complexity burden.
							debug_assert!(
								false,
								"Tried to fulfill an HTLC that was already failed"
							);
							return UpdateFulfillFetch::NewClaim {
								monitor_update,
								htlc_value_msat,
								update_blocked: true,
							};
						}
					},
					_ => {},
				}
			}
			log_trace!(
				logger,
				"Adding HTLC claim to holding_cell! Current state: {}",
				self.context.channel_state.to_u32()
			);
			self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
				payment_preimage: payment_preimage_arg,
				htlc_id: htlc_id_arg,
				attribution_data,
			});
			return UpdateFulfillFetch::NewClaim {
				monitor_update,
				htlc_value_msat,
				update_blocked: true,
			};
		}

		{
			let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
			if let InboundHTLCState::Committed { .. } = htlc.state {
			} else {
				debug_assert!(
					false,
					"Have an inbound HTLC we tried to claim before it was fully committed to"
				);
				return UpdateFulfillFetch::NewClaim {
					monitor_update,
					htlc_value_msat,
					update_blocked: true,
				};
			}
			log_trace!(
				logger,
				"Upgrading HTLC {} to LocalRemoved with a Fulfill!",
				&htlc.payment_hash,
			);
			htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill {
				preimage: payment_preimage_arg.clone(),
				attribution_data,
			});
		}

		UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, update_blocked: false }
	}

	pub fn get_update_fulfill_htlc_and_commit<L: Logger>(
		&mut self, htlc_id: u64, payment_preimage: PaymentPreimage,
		payment_info: Option<PaymentClaimDetails>, attribution_data: Option<AttributionData>,
		logger: &L,
	) -> UpdateFulfillCommitFetch {
		let release_cs_monitor = self.context.blocked_monitor_updates.is_empty();
		match self.get_update_fulfill_htlc(
			htlc_id,
			payment_preimage,
			payment_info,
			attribution_data,
			logger,
		) {
			UpdateFulfillFetch::NewClaim {
				mut monitor_update,
				htlc_value_msat,
				update_blocked,
			} => {
				// Even if we aren't supposed to let new monitor updates with commitment state
				// updates run, we still need to push the preimage ChannelMonitorUpdateStep no
				// matter what. Sadly, to push a new monitor update which flies before others
				// already queued, we have to insert it into the pending queue and update the
				// update_ids of all the following monitors.
				if release_cs_monitor && !update_blocked {
					let mut additional_update = self.build_commitment_no_status_check(logger);
					// build_commitment_no_status_check may bump latest_monitor_id but we want them
					// to be strictly increasing by one, so decrement it here.
					self.context.latest_monitor_update_id = monitor_update.update_id;
					monitor_update.updates.append(&mut additional_update.updates);
				} else {
					let blocked_upd = self.context.blocked_monitor_updates.get(0);
					let new_mon_id = blocked_upd
						.map(|upd| upd.update.update_id)
						.unwrap_or(monitor_update.update_id);
					monitor_update.update_id = new_mon_id;
					for held_update in self.context.blocked_monitor_updates.iter_mut() {
						held_update.update.update_id += 1;
					}
					if !update_blocked {
						debug_assert!(false, "If there is a pending blocked monitor we should have MonitorUpdateInProgress set");
						let update = self.build_commitment_no_status_check(logger);
						self.context
							.blocked_monitor_updates
							.push(PendingChannelMonitorUpdate { update });
					}
				}

				self.monitor_updating_paused(
					false,
					!update_blocked,
					false,
					Vec::new(),
					Vec::new(),
					Vec::new(),
					logger,
				);
				UpdateFulfillCommitFetch::NewClaim { monitor_update, htlc_value_msat }
			},
			UpdateFulfillFetch::DuplicateClaim {} => UpdateFulfillCommitFetch::DuplicateClaim {},
		}
	}

	/// Returns `Err` (always with [`ChannelError::Ignore`]) if the HTLC could not be failed (e.g.
	/// if it was already resolved). Otherwise returns `Ok`.
	pub fn queue_fail_htlc<L: Logger>(
		&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, logger: &L,
	) -> Result<(), ChannelError> {
		self.fail_htlc(htlc_id_arg, err_packet, true, logger)
			.map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
	}

	/// Used for failing back with [`msgs::UpdateFailMalformedHTLC`]. For now, this is used when we
	/// want to fail blinded HTLCs where we are not the intro node.
	///
	/// See [`Self::queue_fail_htlc`] for more info.
	pub fn queue_fail_malformed_htlc<L: Logger>(
		&mut self, htlc_id_arg: u64, failure_code: u16, sha256_of_onion: [u8; 32], logger: &L,
	) -> Result<(), ChannelError> {
		self.fail_htlc(htlc_id_arg, (sha256_of_onion, failure_code), true, logger)
			.map(|msg_opt| assert!(msg_opt.is_none(), "We forced holding cell?"))
	}

	/// Returns `Err` (always with [`ChannelError::Ignore`]) if the HTLC could not be failed (e.g.
	/// if it was already resolved). Otherwise returns `Ok`.
	#[rustfmt::skip]
	fn fail_htlc<L: Logger, E: FailHTLCContents + Clone>(
		&mut self, htlc_id_arg: u64, err_contents: E, mut force_holding_cell: bool,
		logger: &L
	) -> Result<Option<E::Message>, ChannelError> {
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			panic!("Was asked to fail an HTLC when channel was not in an operational state");
		}

		// ChannelManager may generate duplicate claims/fails due to HTLC update events from
		// on-chain ChannelsMonitors during block rescan. Ideally we'd figure out a way to drop
		// these, but for now we just have to treat them as normal.

		let mut pending_idx = core::usize::MAX;
		for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
			if htlc.htlc_id == htlc_id_arg {
				match htlc.state {
					InboundHTLCState::Committed { .. } => {},
					InboundHTLCState::LocalRemoved(_) => {
						return Err(ChannelError::Ignore(format!("HTLC {} was already resolved", htlc.htlc_id)));
					},
					_ => {
						debug_assert!(false, "Have an inbound HTLC we tried to claim before it was fully committed to");
						return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc.htlc_id)));
					}
				}
				pending_idx = idx;
			}
		}
		if pending_idx == core::usize::MAX {
			return Err(ChannelError::Ignore(format!("Unable to find a pending HTLC which matched the given HTLC ID ({})", htlc_id_arg)));
		}

		if !self.context.channel_state.can_generate_new_commitment() {
			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!");
			force_holding_cell = true;
		}

		// Now update local state:
		if force_holding_cell {
			for pending_update in self.context.holding_cell_htlc_updates.iter() {
				match pending_update {
					&HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
						if htlc_id_arg == htlc_id {
							return Err(ChannelError::Ignore(format!("HTLC {} was already claimed!", htlc_id)));
						}
					},
					&HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } |
						&HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } =>
					{
						if htlc_id_arg == htlc_id {
							return Err(ChannelError::Ignore(format!("HTLC {} was already pending failure", htlc_id)));
						}
					},
					_ => {}
				}
			}
			log_trace!(logger, "Placing failure for HTLC ID {} in holding cell.", htlc_id_arg);
			self.context.holding_cell_htlc_updates.push(err_contents.to_htlc_update_awaiting_ack(htlc_id_arg));
			return Ok(None);
		}

		log_trace!(logger, "Failing HTLC ID {} back with {} message.", htlc_id_arg,
			E::Message::name());
		{
			let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
			htlc.state = err_contents.clone().to_inbound_htlc_state();
		}

		Ok(Some(err_contents.to_message(htlc_id_arg, self.context.channel_id())))
	}

	// Message handlers:
	/// Updates the state of the channel to indicate that all channels in the batch have received
	/// funding_signed and persisted their monitors.
	/// The funding transaction is consequently allowed to be broadcast, and the channel can be
	/// treated as a non-batch channel going forward.
	pub fn set_batch_ready(&mut self) {
		self.context.is_batch_funding = None;
		self.context.channel_state.clear_waiting_for_batch();
	}

	/// Unsets the existing funding information for V1 funded channels.
	///
	/// This must only be used if the channel has not yet completed funding and has not been used.
	///
	/// Further, the channel must be immediately shut down after this with a call to
	/// [`ChannelContext::force_shutdown`].
	pub fn unset_funding_info(&mut self) {
		let sent_or_received_tx_signatures = self
			.context
			.interactive_tx_signing_session
			.as_ref()
			.map(|signing_session| {
				signing_session.has_holder_witnesses()
					|| signing_session.has_received_tx_signatures()
			})
			.unwrap_or(false);
		debug_assert!(
			matches!(
				self.context.channel_state,
				ChannelState::FundingNegotiated(_) if !sent_or_received_tx_signatures
			) || matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(_))
		);
		self.context.unset_funding_info(&mut self.funding);
	}

	/// Handles a channel_ready message from our peer. If we've already sent our channel_ready
	/// and the channel is now usable (and public), this may generate an announcement_signatures to
	/// reply with.
	#[rustfmt::skip]
	pub fn channel_ready<NS: NodeSigner, L: Logger>(
		&mut self, msg: &msgs::ChannelReady, node_signer: &NS, chain_hash: ChainHash,
		user_config: &UserConfig, best_block: &BlockLocator, logger: &L
	) -> Result<Option<msgs::AnnouncementSignatures>, ChannelError> {
		if self.context.channel_state.is_peer_disconnected() {
			self.context.workaround_lnd_bug_4006 = Some(msg.clone());
			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()));
		}

		if let Some(scid_alias) = msg.short_channel_id_alias {
			if Some(scid_alias) != self.funding.short_channel_id {
				// The scid alias provided can be used to route payments *from* our counterparty,
				// i.e. can be used for inbound payments and provided in invoices, but is not used
				// when routing outbound payments.
				self.context.latest_inbound_scid_alias = Some(scid_alias);
			}
		}

		// Our channel_ready shouldn't have been sent if we are waiting for other channels in the
		// batch, but we can receive channel_ready messages.
		let mut check_reconnection = false;
		match &self.context.channel_state {
			ChannelState::AwaitingChannelReady(flags) => {
				let flags = flags.clone().clear(FundedStateFlags::ALL.into());
				debug_assert!(!flags.is_set(AwaitingChannelReadyFlags::OUR_CHANNEL_READY) || !flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));
				if flags.clone().clear(AwaitingChannelReadyFlags::WAITING_FOR_BATCH) == AwaitingChannelReadyFlags::THEIR_CHANNEL_READY {
					// If we reconnected before sending our `channel_ready` they may still resend theirs.
					check_reconnection = true;
				} else if flags.clone().clear(AwaitingChannelReadyFlags::WAITING_FOR_BATCH).is_empty() {
					self.context.channel_state.set_their_channel_ready();
				} else if flags == AwaitingChannelReadyFlags::OUR_CHANNEL_READY {
					self.context.channel_state = ChannelState::ChannelReady(self.context.channel_state.with_funded_state_flags_mask().into());
					self.context.update_time_counter += 1;
				} else {
					// We're in `WAITING_FOR_BATCH`, so we should wait until we're ready.
					debug_assert!(flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));
				}
			}
			// If we reconnected before sending our `channel_ready` they may still resend theirs.
			ChannelState::ChannelReady(_) => check_reconnection = true,
			_ => return Err(ChannelError::close("Peer sent a channel_ready at a strange time".to_owned())),
		}
		if check_reconnection {
			// They probably disconnected/reconnected and re-sent the channel_ready, which is
			// required, or they're sending a fresh SCID alias.
			let expected_point =
				if self.context.counterparty_next_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
					// If they haven't ever sent an updated point, the point they send should match
					// the next one.
					self.context.counterparty_next_commitment_point
				} else if self.context.counterparty_next_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
					// If we've advanced the commitment number once, the second commitment point is
					// at `counterparty_current_commitment_point`, which is not yet revoked.
					debug_assert!(self.context.counterparty_current_commitment_point.is_some());
					self.context.counterparty_current_commitment_point
				} else {
					// If they have sent updated points, channel_ready is always supposed to match
					// their "first" point, which we re-derive here.
					Some(PublicKey::from_secret_key(&self.context.secp_ctx, &SecretKey::from_slice(
							&self.context.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
						).expect("We already advanced, so previous secret keys should have been validated already")))
				};
			if expected_point != Some(msg.next_per_commitment_point) {
				return Err(ChannelError::close("Peer sent a reconnect channel_ready with a different point".to_owned()));
			}
			return Ok(None);
		}

		self.context.counterparty_current_commitment_point = self.context.counterparty_next_commitment_point;
		self.context.counterparty_next_commitment_point = Some(msg.next_per_commitment_point);
		self.context.interactive_tx_signing_session = None;

		log_info!(logger, "Received channel_ready from peer for channel {}", &self.context.channel_id());

		Ok(self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block.height, logger))
	}

	#[rustfmt::skip]
	pub fn update_add_htlc<F: FeeEstimator>(
		&mut self, msg: &msgs::UpdateAddHTLC, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<(), ChannelError> {
		if self.context.channel_state.is_remote_stfu_sent() || self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Got add HTLC message while quiescent".to_owned()));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close("Got add HTLC message when channel was not in an operational state".to_owned()));
		}
		// If the remote has sent a shutdown prior to adding this HTLC, then they are in violation of the spec.
		if self.context.channel_state.is_remote_shutdown_sent() {
			return Err(ChannelError::close("Got add HTLC message when channel was not in an operational state".to_owned()));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close("Peer sent update_add_htlc when we needed a channel_reestablish".to_owned()));
		}
		if msg.amount_msat == 0 {
			return Err(ChannelError::close("Remote side tried to send a 0-msat HTLC".to_owned()));
		}
		if msg.amount_msat < self.context.holder_htlc_minimum_msat {
			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)));
		}
		if self.context.next_counterparty_htlc_id != msg.htlc_id {
			return Err(ChannelError::close(format!("Remote skipped HTLC ID (skipped ID: {})", self.context.next_counterparty_htlc_id)));
		}
		if msg.cltv_expiry >= 500000000 {
			return Err(ChannelError::close("Remote provided CLTV expiry in seconds instead of block height".to_owned()));
		}

		core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.try_for_each(|funding| self.context.validate_update_add_htlc(funding, msg, fee_estimator))?;

		// Now update local state:
		self.context.next_counterparty_htlc_id += 1;
		self.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: msg.htlc_id,
			amount_msat: msg.amount_msat,
			payment_hash: msg.payment_hash,
			cltv_expiry: msg.cltv_expiry,
			state: InboundHTLCState::RemoteAnnounced(InboundHTLCResolution::Pending {
				update_add_htlc: msg.clone(),
			}),
		});
		Ok(())
	}

	/// Returns true if any committed inbound HTLCs were received before we started serializing
	/// inbound committed payment onions in `Channel` and cannot be used during `ChannelManager`
	/// deserialization to reconstruct the set of pending HTLCs.
	pub(super) fn has_legacy_inbound_htlcs(&self) -> bool {
		self.context.pending_inbound_htlcs.iter().any(|htlc| {
			matches!(
				&htlc.state,
				InboundHTLCState::Committed { update_add_htlc: InboundUpdateAdd::Legacy }
			)
		})
	}

	/// Returns committed inbound HTLCs whose onion has not yet been decoded and processed. Useful
	/// for reconstructing the set of pending HTLCs when deserializing the `ChannelManager`.
	pub(super) fn inbound_htlcs_pending_decode(
		&self,
	) -> impl Iterator<Item = msgs::UpdateAddHTLC> + '_ {
		self.context.pending_inbound_htlcs.iter().filter_map(|htlc| match &htlc.state {
			InboundHTLCState::Committed {
				update_add_htlc: InboundUpdateAdd::WithOnion { update_add_htlc },
			} => Some(update_add_htlc.clone()),
			_ => None,
		})
	}

	/// Returns committed inbound HTLCs that have been forwarded but not yet fully resolved. Useful
	/// when reconstructing the set of pending HTLCs when deserializing the `ChannelManager`.
	pub(super) fn inbound_forwarded_htlcs(
		&self,
	) -> impl Iterator<Item = (PaymentHash, HTLCPreviousHopData, OutboundHop)> + '_ {
		// We don't want to return an HTLC as needing processing if it already has a resolution that's
		// pending in the holding cell.
		let htlc_resolution_in_holding_cell = |id: u64| -> bool {
			self.context.holding_cell_htlc_updates.iter().any(|holding_cell_htlc| {
				match holding_cell_htlc {
					HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => *htlc_id == id,
					HTLCUpdateAwaitingACK::FailHTLC { htlc_id, .. } => *htlc_id == id,
					HTLCUpdateAwaitingACK::FailMalformedHTLC { htlc_id, .. } => *htlc_id == id,
					HTLCUpdateAwaitingACK::AddHTLC { .. } => false,
				}
			})
		};

		let prev_outbound_scid_alias = self.context.outbound_scid_alias();
		let user_channel_id = self.context.get_user_id();
		let channel_id = self.context.channel_id();
		let outpoint = self.funding_outpoint();
		let counterparty_node_id = self.context.get_counterparty_node_id();

		self.context.pending_inbound_htlcs.iter().filter_map(move |htlc| match &htlc.state {
			InboundHTLCState::Committed {
				update_add_htlc:
					InboundUpdateAdd::Forwarded {
						incoming_packet_shared_secret,
						phantom_shared_secret,
						trampoline_shared_secret,
						blinded_failure,
						outbound_hop,
					},
			} => {
				if htlc_resolution_in_holding_cell(htlc.htlc_id) {
					return None;
				}
				// The reconstructed `HTLCPreviousHopData` is used to fail or claim the HTLC backwards
				// post-restart, if it is missing in the outbound edge.
				let prev_hop_data = HTLCPreviousHopData {
					prev_outbound_scid_alias,
					user_channel_id: Some(user_channel_id),
					amount_msat: Some(htlc.amount_msat),
					htlc_id: htlc.htlc_id,
					incoming_packet_shared_secret: *incoming_packet_shared_secret,
					phantom_shared_secret: *phantom_shared_secret,
					trampoline_shared_secret: *trampoline_shared_secret,
					blinded_failure: *blinded_failure,
					channel_id,
					outpoint,
					counterparty_node_id: Some(counterparty_node_id),
					cltv_expiry: Some(htlc.cltv_expiry),
				};
				Some((htlc.payment_hash, prev_hop_data, *outbound_hop))
			},
			_ => None,
		})
	}

	/// Useful when reconstructing the set of pending HTLC forwards when deserializing the
	/// `ChannelManager`. We don't want to cache an HTLC as needing to be forwarded if it's already
	/// present in the outbound edge, or else we'll double-forward.
	pub(super) fn outbound_htlc_forwards(
		&self,
	) -> impl Iterator<Item = (PaymentHash, HTLCPreviousHopData)> + '_ {
		let holding_cell_outbounds =
			self.context.holding_cell_htlc_updates.iter().filter_map(|htlc| match htlc {
				HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. } => match source {
					HTLCSource::PreviousHopData(prev_hop_data) => {
						Some((*payment_hash, prev_hop_data.clone()))
					},
					_ => None,
				},
				_ => None,
			});
		let committed_outbounds =
			self.context.pending_outbound_htlcs.iter().filter_map(|htlc| match &htlc.source {
				HTLCSource::PreviousHopData(prev_hop_data) => {
					Some((htlc.payment_hash, prev_hop_data.clone()))
				},
				_ => None,
			});
		holding_cell_outbounds.chain(committed_outbounds)
	}

	#[cfg(test)]
	pub(super) fn test_holding_cell_outbound_htlc_forwards_count(&self) -> usize {
		self.context
			.holding_cell_htlc_updates
			.iter()
			.filter_map(|htlc| match htlc {
				HTLCUpdateAwaitingACK::AddHTLC { source, .. } => match source {
					HTLCSource::PreviousHopData(prev_hop_data) => Some(prev_hop_data.clone()),
					_ => None,
				},
				_ => None,
			})
			.count()
	}

	/// This inbound HTLC was irrevocably forwarded to the outbound edge, so we no longer need to
	/// persist its onion.
	pub(super) fn prune_inbound_htlc_onion(
		&mut self, htlc_id: u64, prev_hop_data: &HTLCPreviousHopData,
		outbound_hop_data: OutboundHop,
	) {
		for htlc in self.context.pending_inbound_htlcs.iter_mut() {
			if htlc.htlc_id == htlc_id {
				if let InboundHTLCState::Committed { ref mut update_add_htlc } = htlc.state {
					*update_add_htlc = InboundUpdateAdd::Forwarded {
						incoming_packet_shared_secret: prev_hop_data.incoming_packet_shared_secret,
						phantom_shared_secret: prev_hop_data.phantom_shared_secret,
						trampoline_shared_secret: prev_hop_data.trampoline_shared_secret,
						blinded_failure: prev_hop_data.blinded_failure,
						outbound_hop: outbound_hop_data,
					};
					return;
				}
			}
		}
		debug_assert!(false, "If we go to prune an inbound HTLC it should be present")
	}

	/// Clears the `hold_htlc` flag for a pending inbound HTLC, returning `true` if the HTLC was
	/// successfully released. Useful when a [`ReleaseHeldHtlc`] onion message arrives before the
	/// HTLC has been fully committed.
	///
	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
	pub(super) fn release_pending_inbound_held_htlc(&mut self, htlc_id: u64) -> bool {
		for update_add in self.context.monitor_pending_update_adds.iter_mut() {
			if update_add.htlc_id == htlc_id {
				update_add.hold_htlc.take();
				return true;
			}
		}
		for htlc in self.context.pending_inbound_htlcs.iter_mut() {
			if htlc.htlc_id != htlc_id {
				continue;
			}
			match &mut htlc.state {
				// Clearing `hold_htlc` here directly affects the copy that will be cloned into the decode
				// pipeline when RAA promotes the HTLC.
				InboundHTLCState::RemoteAnnounced(InboundHTLCResolution::Pending {
					update_add_htlc,
				})
				| InboundHTLCState::AwaitingRemoteRevokeToAnnounce(
					InboundHTLCResolution::Pending { update_add_htlc },
				)
				| InboundHTLCState::AwaitingAnnouncedRemoteRevoke(
					InboundHTLCResolution::Pending { update_add_htlc },
				) => {
					update_add_htlc.hold_htlc.take();
					return true;
				},
				_ => return false,
			}
		}
		false
	}

	/// Useful for testing crash scenarios where the holding cell is not persisted.
	#[cfg(test)]
	pub(super) fn test_clear_holding_cell(&mut self) {
		self.context.holding_cell_htlc_updates.clear()
	}

	/// Marks an outbound HTLC which we have received update_fail/fulfill/malformed
	#[inline]
	fn mark_outbound_htlc_removed(
		&mut self, htlc_id: u64, outcome: OutboundHTLCOutcome,
	) -> Result<&OutboundHTLCOutput, ChannelError> {
		for htlc in self.context.pending_outbound_htlcs.iter_mut() {
			if htlc.htlc_id == htlc_id {
				if let OutboundHTLCOutcome::Success { ref preimage, .. } = outcome {
					let payment_hash = PaymentHash(Sha256::hash(&preimage.0[..]).to_byte_array());
					if payment_hash != htlc.payment_hash {
						return Err(ChannelError::close(format!(
							"Remote tried to fulfill HTLC ({}) with an incorrect preimage",
							htlc_id
						)));
					}
				}
				match htlc.state {
					OutboundHTLCState::LocalAnnounced(_) =>
						return Err(ChannelError::close(format!("Remote tried to fulfill/fail HTLC ({}) before it had been committed", htlc_id))),
					OutboundHTLCState::Committed => {
						htlc.state = OutboundHTLCState::RemoteRemoved(outcome);
					},
					OutboundHTLCState::AwaitingRemoteRevokeToRemove(_) | OutboundHTLCState::AwaitingRemovedRemoteRevoke(_) | OutboundHTLCState::RemoteRemoved(_) =>
						return Err(ChannelError::close(format!("Remote tried to fulfill/fail HTLC ({}) that they'd already fulfilled/failed", htlc_id))),
				}
				return Ok(htlc);
			}
		}
		Err(ChannelError::close("Remote tried to fulfill/fail an HTLC we couldn't find".to_owned()))
	}

	pub fn update_fulfill_htlc(
		&mut self, msg: &msgs::UpdateFulfillHTLC,
	) -> Result<(HTLCSource, u64, Option<u64>, Option<Duration>), ChannelError> {
		if self.context.channel_state.is_remote_stfu_sent()
			|| self.context.channel_state.is_quiescent()
		{
			return Err(ChannelError::WarnAndDisconnect(
				"Got fulfill HTLC message while quiescent".to_owned(),
			));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close(
				"Got fulfill HTLC message when channel was not in an operational state".to_owned(),
			));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close(
				"Peer sent update_fulfill_htlc when we needed a channel_reestablish".to_owned(),
			));
		}

		let outcome = OutboundHTLCOutcome::Success {
			preimage: msg.payment_preimage,
			attribution_data: msg.attribution_data.clone(),
		};
		self.mark_outbound_htlc_removed(msg.htlc_id, outcome).map(|htlc| {
			(htlc.source.clone(), htlc.amount_msat, htlc.skimmed_fee_msat, htlc.send_timestamp)
		})
	}

	#[rustfmt::skip]
	pub fn update_fail_htlc(&mut self, msg: &msgs::UpdateFailHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
		if self.context.channel_state.is_remote_stfu_sent() || self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Got fail HTLC message while quiescent".to_owned()));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close("Got fail HTLC message when channel was not in an operational state".to_owned()));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close("Peer sent update_fail_htlc when we needed a channel_reestablish".to_owned()));
		}

		self.mark_outbound_htlc_removed(msg.htlc_id, OutboundHTLCOutcome::Failure(fail_reason))?;
		Ok(())
	}

	#[rustfmt::skip]
	pub fn update_fail_malformed_htlc(&mut self, msg: &msgs::UpdateFailMalformedHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
		if self.context.channel_state.is_remote_stfu_sent() || self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Got fail malformed HTLC message while quiescent".to_owned()));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close("Got fail malformed HTLC message when channel was not in an operational state".to_owned()));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close("Peer sent update_fail_malformed_htlc when we needed a channel_reestablish".to_owned()));
		}

		self.mark_outbound_htlc_removed(msg.htlc_id, OutboundHTLCOutcome::Failure(fail_reason))?;
		Ok(())
	}

	pub fn initial_commitment_signed_v2<L: Logger>(
		&mut self, msg: &msgs::CommitmentSigned, best_block: BlockLocator, signer_provider: &SP,
		logger: &L,
	) -> Result<ChannelMonitor<SP::EcdsaSigner>, ChannelError> {
		if let Some(signing_session) = self.context.interactive_tx_signing_session.as_ref() {
			if signing_session.has_received_tx_signatures() {
				let msg = "Received initial commitment_signed after peer's tx_signatures received!";
				let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
				return Err(ChannelError::Close((msg.to_owned(), reason)));
			}
		} else {
			let msg = "Received initial commitment_signed before funding transaction constructed!";
			let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
			return Err(ChannelError::Close((msg.to_owned(), reason)));
		};

		let holder_commitment_point = &mut self.holder_commitment_point.clone();
		self.context.assert_no_commitment_advancement(
			holder_commitment_point.next_transaction_number(),
			"initial commitment_signed",
		);

		let (channel_monitor, _) = self.initial_commitment_signed(
			self.context.channel_id(),
			msg.signature,
			holder_commitment_point,
			best_block,
			signer_provider,
			logger,
		)?;
		self.holder_commitment_point = *holder_commitment_point;

		log_info!(
			logger,
			"Received initial commitment_signed from peer for channel {}",
			&self.context.channel_id()
		);

		self.monitor_updating_paused(
			false,
			false,
			false,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);
		self.context
			.interactive_tx_signing_session
			.as_mut()
			.expect("signing session should be present")
			.received_commitment_signed();
		Ok(channel_monitor)
	}

	/// Handles an incoming `commitment_signed` message for the first commitment transaction of the
	/// channel's new funding transaction. This assumes our `commitment_signed` was already sent
	/// when the [`InteractiveTxSigningSession`] was initialized, so we do not need to send one in
	/// response. As a result, a single [`ChannelMonitorUpdate`] will get queued that tracks the new
	/// set of channel parameters, as well as the initial holder and counterparty commitment
	/// transactions. We hold back sending our `tx_signatures` until the monitor update is
	/// persisted, such that we're able to enforce the holder commitment transaction onchain once
	/// the new funding transaction is signed and broadcast.
	///
	/// Note that our `commitment_signed` send did not include a monitor update. This is due to:
	///   1. Updates cannot be made since the state machine is paused until `tx_signatures`.
	///   2. We're still able to abort negotiation until `tx_signatures`.
	fn splice_initial_commitment_signed<F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::CommitmentSigned, fee_estimator: &LowerBoundedFeeEstimator<F>,
		logger: &L,
	) -> Result<Option<ChannelMonitorUpdate>, ChannelError> {
		debug_assert!(self
			.context
			.interactive_tx_signing_session
			.as_ref()
			.map(|signing_session| !signing_session.has_received_tx_signatures())
			.unwrap_or(false));

		let pending_splice_funding = self
			.pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
			.filter(|funding_negotiation| {
				matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures { .. })
			})
			.and_then(|funding_negotiation| funding_negotiation.as_funding())
			.expect("Funding must exist for negotiated pending splice");

		let transaction_number = self.holder_commitment_point.current_transaction_number();
		let commitment_point = self.holder_commitment_point.current_point().ok_or_else(|| {
			debug_assert!(false);
			ChannelError::close(
				"current_point should be set for channels initiating splicing".to_owned(),
			)
		})?;
		let (holder_commitment_tx, _) = self.context.validate_commitment_signed(
			pending_splice_funding,
			transaction_number,
			commitment_point,
			msg,
			fee_estimator,
			logger,
		)?;
		// This corresponds to the same `commitment_signed` we sent earlier, which we know to be the
		// same since the state machine is paused until `tx_signatures` are exchanged.
		let counterparty_commitment_tx = self
			.context
			.build_commitment_transaction(
				pending_splice_funding,
				self.context.counterparty_next_commitment_transaction_number + 1,
				&self.context.counterparty_current_commitment_point.unwrap(),
				false,
				false,
				logger,
			)
			.tx;

		{
			let counterparty_trusted_tx = counterparty_commitment_tx.trust();
			let counterparty_bitcoin_tx = counterparty_trusted_tx.built_transaction();
			log_trace!(
				logger,
				"Splice initial counterparty tx is: txid {} tx {}",
				counterparty_bitcoin_tx.txid,
				encode::serialize_hex(&counterparty_bitcoin_tx.transaction)
			);
		}

		let funding_contribution = self
			.pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.negotiation_contribution.as_ref())
			.cloned();

		log_info!(
			logger,
			"Received splice initial commitment_signed from peer with funding txid {}",
			pending_splice_funding.get_funding_txo().unwrap().txid
		);

		self.context.latest_monitor_update_id += 1;
		let monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![ChannelMonitorUpdateStep::RenegotiatedFunding {
				channel_parameters: pending_splice_funding.channel_transaction_parameters.clone(),
				holder_commitment_tx,
				counterparty_commitment_tx,
				funding_contribution,
			}],
			channel_id: Some(self.context.channel_id()),
		};

		self.context
			.interactive_tx_signing_session
			.as_mut()
			.expect("Signing session must exist for negotiated pending splice")
			.received_commitment_signed();
		self.monitor_updating_paused(
			false,
			false,
			false,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);
		self.context.monitor_pending_tx_signatures = true;

		Ok(self.push_ret_blockable_mon_update(monitor_update))
	}

	fn get_commitment_htlc_data<'a>(
		htlcs_included: &'a [(HTLCOutputInCommitment, Option<&HTLCSource>)],
	) -> (
		impl Iterator<Item = HTLCSource> + 'a,
		impl Iterator<Item = (HTLCOutputInCommitment, Option<HTLCSource>)> + 'a,
	) {
		let nondust_htlc_sources = htlcs_included
			.iter()
			.filter(|(htlc, _)| htlc.transaction_output_index.is_some() && htlc.offered)
			.map(|(_, source_opt)| source_opt.cloned().expect("Missing outbound HTLC source"));
		let dust_htlcs = htlcs_included
			.iter()
			.filter(|(htlc, _)| htlc.transaction_output_index.is_none())
			.map(|(htlc, source_opt)| (htlc.clone(), source_opt.cloned()));
		(nondust_htlc_sources, dust_htlcs)
	}

	pub fn commitment_signed<F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::CommitmentSigned, fee_estimator: &LowerBoundedFeeEstimator<F>,
		logger: &L,
	) -> Result<Option<ChannelMonitorUpdate>, ChannelError> {
		self.commitment_signed_check_state()?;

		if let Some(funding_txid) = msg.funding_txid {
			// We may have aborted a pending funding negotiation while the counterparty's initial
			// `commitment_signed` was in flight.
			let is_known_funding = core::iter::once(&self.funding)
				.chain(self.pending_funding())
				.any(|funding| funding.get_funding_txid() == Some(funding_txid));
			if !is_known_funding {
				return Err(ChannelError::Ignore(format!(
					"Ignoring commitment_signed for stale funding txid {funding_txid}"
				)));
			}
		}

		if !self.negotiated_candidates().is_empty() {
			return Err(ChannelError::close(
				"Got a single commitment_signed message when expecting a batch".to_owned(),
			));
		}

		let transaction_number = self.holder_commitment_point.next_transaction_number();
		let commitment_point = self.holder_commitment_point.next_point();
		let update = self
			.context
			.validate_commitment_signed(
				&self.funding,
				transaction_number,
				commitment_point,
				msg,
				fee_estimator,
				logger,
			)
			.map(|(commitment_tx, htlcs_included)| {
				let (nondust_htlc_sources, dust_htlcs) =
					Self::get_commitment_htlc_data(&htlcs_included);
				let htlc_outputs =
					dust_htlcs.into_iter().map(|(htlc, source)| (htlc, None, source)).collect();
				ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
					commitment_tx,
					htlc_outputs,
					claimed_htlcs: vec![],
					nondust_htlc_sources: nondust_htlc_sources.collect(),
				}
			})?;

		self.commitment_signed_update_monitor(update, logger)
	}

	pub fn commitment_signed_batch<F: FeeEstimator, L: Logger>(
		&mut self, batch: Vec<msgs::CommitmentSigned>, fee_estimator: &LowerBoundedFeeEstimator<F>,
		logger: &L,
	) -> Result<Option<ChannelMonitorUpdate>, ChannelError> {
		self.commitment_signed_check_state()?;

		let mut messages = BTreeMap::new();
		for msg in batch {
			let funding_txid = match msg.funding_txid {
				Some(funding_txid) => funding_txid,
				None => {
					return Err(ChannelError::close(
						"Peer sent batched commitment_signed without a funding_txid".to_string(),
					));
				},
			};

			match messages.entry(funding_txid) {
				btree_map::Entry::Vacant(entry) => {
					entry.insert(msg);
				},
				btree_map::Entry::Occupied(_) => {
					return Err(ChannelError::close(format!(
						"Peer sent batched commitment_signed with duplicate funding_txid {}",
						funding_txid
					)));
				},
			}
		}

		// Any commitment_signed not associated with a FundingScope is ignored below if a
		// pending splice transaction has confirmed since receiving the batch.
		let mut commitment_txs = Vec::with_capacity(self.pending_funding().len() + 1);
		let mut htlc_data = None;
		for funding in core::iter::once(&self.funding).chain(self.pending_funding()) {
			let funding_txid =
				funding.get_funding_txid().expect("Funding txid must be known for pending scope");
			let msg = messages.get(&funding_txid).ok_or_else(|| {
				ChannelError::close(format!(
					"Peer did not send a commitment_signed for pending splice transaction: {}",
					funding_txid
				))
			})?;
			let transaction_number = self.holder_commitment_point.next_transaction_number();
			let commitment_point = self.holder_commitment_point.next_point();
			let (commitment_tx, htlcs_included) = self.context.validate_commitment_signed(
				funding,
				transaction_number,
				commitment_point,
				msg,
				fee_estimator,
				logger,
			)?;
			commitment_txs.push(commitment_tx);
			if htlc_data.is_none() {
				let (nondust_htlc_sources, dust_htlcs) =
					Self::get_commitment_htlc_data(&htlcs_included);
				htlc_data = Some(CommitmentHTLCData {
					nondust_htlc_sources: nondust_htlc_sources.collect(),
					dust_htlcs: dust_htlcs.collect(),
				});
			}
		}

		let update = ChannelMonitorUpdateStep::LatestHolderCommitment {
			commitment_txs,
			htlc_data: htlc_data.expect("At least one funding scope must have been considered"),
			claimed_htlcs: Vec::new(),
		};
		self.commitment_signed_update_monitor(update, logger)
	}

	fn commitment_signed_check_state(&self) -> Result<(), ChannelError> {
		if self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect(
				"Got commitment_signed message while quiescent".to_owned(),
			));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close(
				"Got commitment signed message when channel was not in an operational state"
					.to_owned(),
			));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close(
				"Peer sent commitment_signed when we needed a channel_reestablish".to_owned(),
			));
		}
		if self.context.channel_state.is_both_sides_shutdown()
			&& self.context.last_sent_closing_fee.is_some()
		{
			return Err(ChannelError::close(
				"Peer sent commitment_signed after we'd started exchanging closing_signeds"
					.to_owned(),
			));
		}

		Ok(())
	}

	fn commitment_signed_update_monitor<L: Logger>(
		&mut self, mut update: ChannelMonitorUpdateStep, logger: &L,
	) -> Result<Option<ChannelMonitorUpdate>, ChannelError> {
		if self
			.holder_commitment_point
			.advance(&self.context.holder_signer, &self.context.secp_ctx, logger)
			.is_err()
		{
			// We only fail to advance our commitment point/number if we're currently
			// waiting for our signer to unblock and provide a commitment point.
			// During post-funding channel operation, we only advance our point upon
			// receiving a commitment_signed, and our counterparty cannot send us
			// another commitment signed until we've provided a new commitment point
			// in revoke_and_ack, which requires unblocking our signer and completing
			// the advance to the next point. This should be unreachable since
			// a new commitment_signed should fail at our signature checks in
			// validate_commitment_signed.
			debug_assert!(false, "We should be ready to advance our commitment point by the time we receive commitment_signed");
			return Err(ChannelError::close("Failed to advance our commitment point".to_owned()));
		}

		// Update state now that we've passed all the can-fail calls...
		let mut need_commitment = false;
		if let &mut Some((_, ref mut update_state)) = &mut self.context.pending_update_fee {
			if *update_state == FeeUpdateState::RemoteAnnounced {
				*update_state = FeeUpdateState::AwaitingRemoteRevokeToAnnounce;
				need_commitment = true;
			}
		}

		for htlc in self.context.pending_inbound_htlcs.iter_mut() {
			if let &InboundHTLCState::RemoteAnnounced(ref htlc_resolution) = &htlc.state {
				log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToAnnounce due to commitment_signed in channel {}.",
					&htlc.payment_hash, &self.context.channel_id);
				htlc.state =
					InboundHTLCState::AwaitingRemoteRevokeToAnnounce(htlc_resolution.clone());
				need_commitment = true;
			}
		}
		let mut claimed_htlcs = Vec::new();
		for htlc in self.context.pending_outbound_htlcs.iter_mut() {
			if let &mut OutboundHTLCState::RemoteRemoved(ref mut outcome) = &mut htlc.state {
				log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToRemove due to commitment_signed in channel {}.",
					&htlc.payment_hash, &self.context.channel_id);
				// Swap against a dummy variant to avoid a potentially expensive clone of `OutboundHTLCOutcome::Failure(HTLCFailReason)`
				let mut reason = OutboundHTLCOutcome::Success {
					preimage: PaymentPreimage([0u8; 32]),
					attribution_data: None,
				};
				mem::swap(outcome, &mut reason);
				if let OutboundHTLCOutcome::Success { preimage, .. } = reason {
					// If a user (a) receives an HTLC claim using LDK 0.0.104 or before, then (b)
					// upgrades to LDK 0.0.114 or later before the HTLC is fully resolved, we could
					// have a `Success(None)` reason. In this case we could forget some HTLC
					// claims, but such an upgrade is unlikely and including claimed HTLCs here
					// fixes a bug which the user was exposed to on 0.0.104 when they started the
					// claim anyway.
					claimed_htlcs.push((SentHTLCId::from_source(&htlc.source), preimage));
				}
				htlc.state = OutboundHTLCState::AwaitingRemoteRevokeToRemove(reason);
				need_commitment = true;
			}
		}

		match &mut update {
			ChannelMonitorUpdateStep::LatestHolderCommitment {
				claimed_htlcs: ref mut update_claimed_htlcs,
				..
			} => {
				debug_assert!(update_claimed_htlcs.is_empty());
				*update_claimed_htlcs = claimed_htlcs.clone();
			},
			ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
				claimed_htlcs: ref mut update_claimed_htlcs,
				..
			} => {
				debug_assert!(update_claimed_htlcs.is_empty());
				*update_claimed_htlcs = claimed_htlcs.clone();
			},
			_ => debug_assert!(false),
		}

		self.context.latest_monitor_update_id += 1;
		let mut monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![update],
			channel_id: Some(self.context.channel_id()),
		};

		self.context.expecting_peer_commitment_signed = false;
		// Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
		// build_commitment_no_status_check() next which will reset this to RAAFirst.
		self.context.resend_order = RAACommitmentOrder::CommitmentFirst;

		if self.context.channel_state.is_monitor_update_in_progress() {
			// In case we initially failed monitor updating without requiring a response, we need
			// to make sure the RAA gets sent first.
			self.context.monitor_pending_revoke_and_ack = true;
			if need_commitment && !self.context.channel_state.is_awaiting_remote_revoke() {
				// If we were going to send a commitment_signed after the RAA, go ahead and do all
				// the corresponding HTLC status updates so that
				// get_last_commitment_update_for_send includes the right HTLCs.
				self.context.monitor_pending_commitment_signed = true;
				let mut additional_update = self.build_commitment_no_status_check(logger);
				// build_commitment_no_status_check may bump latest_monitor_id but we want them to be
				// strictly increasing by one, so decrement it here.
				self.context.latest_monitor_update_id = monitor_update.update_id;
				monitor_update.updates.append(&mut additional_update.updates);
			}
			log_debug!(logger, "Received valid commitment_signed from peer, updated HTLC state but awaiting a monitor update resolution to reply.",
				);
			return Ok(self.push_ret_blockable_mon_update(monitor_update));
		}

		let need_commitment_signed =
			if need_commitment && !self.context.channel_state.is_awaiting_remote_revoke() {
				// If we're AwaitingRemoteRevoke we can't send a new commitment here, but that's ok -
				// we'll send one right away when we get the revoke_and_ack when we
				// free_holding_cell_htlcs().
				let mut additional_update = self.build_commitment_no_status_check(logger);
				// build_commitment_no_status_check may bump latest_monitor_id but we want them to be
				// strictly increasing by one, so decrement it here.
				self.context.latest_monitor_update_id = monitor_update.update_id;
				monitor_update.updates.append(&mut additional_update.updates);
				true
			} else {
				false
			};

		log_debug!(logger, "Received valid commitment_signed from peer in channel {}, updating HTLC state and responding with{} a revoke_and_ack.",
			&self.context.channel_id(), if need_commitment_signed { " our own commitment_signed and" } else { "" });
		self.monitor_updating_paused(
			true,
			need_commitment_signed,
			false,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);
		return Ok(self.push_ret_blockable_mon_update(monitor_update));
	}

	/// Public version of the below, checking relevant preconditions first.
	/// If we're not in a state where freeing the holding cell makes sense, this is a no-op and
	/// returns `(None, Vec::new())`.
	pub fn maybe_free_holding_cell_htlcs<F: FeeEstimator, L: Logger>(
		&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) {
		if matches!(self.context.channel_state, ChannelState::ChannelReady(_))
			&& self.context.channel_state.can_generate_new_commitment()
		{
			self.free_holding_cell_htlcs(fee_estimator, logger)
		} else {
			(None, Vec::new())
		}
	}

	/// Frees any pending commitment updates in the holding cell, generating the relevant messages
	/// for our counterparty.
	fn free_holding_cell_htlcs<F: FeeEstimator, L: Logger>(
		&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> (Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) {
		assert!(matches!(self.context.channel_state, ChannelState::ChannelReady(_)));
		assert!(!self.context.channel_state.is_monitor_update_in_progress());
		assert!(!self.context.channel_state.is_quiescent());
		if self.context.holding_cell_htlc_updates.len() != 0
			|| self.context.holding_cell_update_fee.is_some()
		{
			log_trace!(
				logger,
				"Freeing holding cell with {} HTLC updates{}",
				self.context.holding_cell_htlc_updates.len(),
				if self.context.holding_cell_update_fee.is_some() {
					" and a fee update"
				} else {
					""
				},
			);

			let mut monitor_update = ChannelMonitorUpdate {
				update_id: self.context.latest_monitor_update_id + 1, // We don't increment this yet!
				updates: Vec::new(),
				channel_id: Some(self.context.channel_id()),
			};

			let mut htlc_updates = Vec::new();
			mem::swap(&mut htlc_updates, &mut self.context.holding_cell_htlc_updates);
			let mut update_add_count = 0;
			let mut update_fulfill_count = 0;
			let mut update_fail_count = 0;
			let mut htlcs_to_fail = Vec::new();
			for htlc_update in htlc_updates.drain(..) {
				// Note that this *can* fail, though it should be due to rather-rare conditions on
				// fee races with adding too many outputs which push our total payments just over
				// the limit. In case it's less rare than I anticipate, we may want to revisit
				// handling this case better and maybe fulfilling some of the HTLCs while attempting
				// to rebalance channels.
				let fail_htlc_res = match &htlc_update {
					&HTLCUpdateAwaitingACK::AddHTLC {
						amount_msat,
						cltv_expiry,
						ref payment_hash,
						ref source,
						ref onion_routing_packet,
						skimmed_fee_msat,
						blinding_point,
						hold_htlc,
						accountable,
					} => {
						match self.send_htlc(
							amount_msat,
							*payment_hash,
							cltv_expiry,
							source.clone(),
							onion_routing_packet.clone(),
							false,
							skimmed_fee_msat,
							blinding_point,
							hold_htlc.is_some(),
							accountable,
							fee_estimator,
							logger,
						) {
							Ok(can_add_htlc) => {
								// `send_htlc` only returns `Ok(false)`, when an update goes into
								// the holding cell, but since we're currently freeing it, we should
								// always expect to see the htlc added.
								debug_assert!(
									can_add_htlc,
									"Must generate new update if we're freeing the holding cell"
								);
								update_add_count += 1;
							},
							Err((_, msg)) => {
								log_info!(
									logger,
									"Failed to send HTLC with payment_hash {} due to {}",
									&payment_hash,
									msg
								);
								// If we fail to send here, then this HTLC should be failed
								// backwards. Failing to send here indicates that this HTLC may
								// keep being put back into the holding cell without ever being
								// successfully forwarded/failed/fulfilled, causing our
								// counterparty to eventually close on us.
								htlcs_to_fail.push((source.clone(), *payment_hash));
							},
						}
						None
					},
					&HTLCUpdateAwaitingACK::ClaimHTLC {
						ref payment_preimage,
						htlc_id,
						ref attribution_data,
					} => {
						// If an HTLC claim was previously added to the holding cell (via
						// `get_update_fulfill_htlc`, then generating the claim message itself must
						// not fail - any in between attempts to claim the HTLC will have resulted
						// in it hitting the holding cell again and we cannot change the state of a
						// holding cell HTLC from fulfill to anything else.
						//
						// Note that we should have already provided a preimage-containing
						// `ChannelMonitorUpdate` to the user, making this one redundant, however
						// there's no harm in including the extra `ChannelMonitorUpdateStep` here.
						// We do not bother to track and include `payment_info` here, however.
						let fulfill = self.get_update_fulfill_htlc(
							htlc_id,
							*payment_preimage,
							None,
							attribution_data.clone(),
							logger,
						);
						let mut additional_monitor_update =
							if let UpdateFulfillFetch::NewClaim { monitor_update, .. } = fulfill {
								monitor_update
							} else {
								unreachable!()
							};
						update_fulfill_count += 1;
						monitor_update.updates.append(&mut additional_monitor_update.updates);
						None
					},
					&HTLCUpdateAwaitingACK::FailHTLC { htlc_id, ref err_packet } => Some(
						self.fail_htlc(htlc_id, err_packet.clone(), false, logger)
							.map(|fail_msg_opt| fail_msg_opt.map(|_| ())),
					),
					&HTLCUpdateAwaitingACK::FailMalformedHTLC {
						htlc_id,
						failure_code,
						sha256_of_onion,
					} => Some(
						self.fail_htlc(htlc_id, (sha256_of_onion, failure_code), false, logger)
							.map(|fail_msg_opt| fail_msg_opt.map(|_| ())),
					),
				};
				if let Some(res) = fail_htlc_res {
					match res {
						Ok(fail_msg_opt) => {
							// If an HTLC failure was previously added to the holding cell (via
							// `queue_fail_{malformed_}htlc`) then generating the fail message itself must
							// not fail - we should never end up in a state where we double-fail
							// an HTLC or fail-then-claim an HTLC as it indicates we didn't wait
							// for a full revocation before failing.
							debug_assert!(fail_msg_opt.is_some());
							update_fail_count += 1;
						},
						Err(ChannelError::Ignore(_)) => {},
						Err(_) => {
							panic!("Got a non-IgnoreError action trying to fail holding cell HTLC");
						},
					}
				}
			}
			let update_fee =
				self.context.holding_cell_update_fee.take().and_then(|feerate| {
					self.send_update_fee(feerate, false, fee_estimator, logger)
				});

			if update_add_count == 0
				&& update_fulfill_count == 0
				&& update_fail_count == 0
				&& update_fee.is_none()
			{
				return (None, htlcs_to_fail);
			}

			let mut additional_update = self.build_commitment_no_status_check(logger);
			// build_commitment_no_status_check and get_update_fulfill_htlc may bump latest_monitor_id
			// but we want them to be strictly increasing by one, so reset it here.
			self.context.latest_monitor_update_id = monitor_update.update_id;
			monitor_update.updates.append(&mut additional_update.updates);

			log_debug!(logger, "Freeing holding cell resulted in {}{} HTLCs added, {} HTLCs fulfilled, and {} HTLCs failed.",
				if update_fee.is_some() { "a fee update, " } else { "" },
				update_add_count, update_fulfill_count, update_fail_count);

			self.monitor_updating_paused(
				false,
				true,
				false,
				Vec::new(),
				Vec::new(),
				Vec::new(),
				logger,
			);
			(self.push_ret_blockable_mon_update(monitor_update), htlcs_to_fail)
		} else {
			(None, Vec::new())
		}
	}

	/// Handles receiving a remote's revoke_and_ack. Note that we may return a new
	/// commitment_signed message here in case we had pending outbound HTLCs to add which were
	/// waiting on this revoke_and_ack. The generation of this new commitment_signed may also fail,
	/// generating an appropriate error *after* the channel state has been updated based on the
	/// revoke_and_ack message.
	///
	/// The static invoices will be used by us as an async sender to enqueue [`HeldHtlcAvailable`]
	/// onion messages for the often-offline recipient, and the blinded reply paths the invoices are
	/// paired with were created by our channel counterparty and will be used as reply paths for
	/// corresponding [`ReleaseHeldHtlc`] messages.
	///
	/// [`HeldHtlcAvailable`]: crate::onion_message::async_payments::HeldHtlcAvailable
	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
	pub fn revoke_and_ack<F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::RevokeAndACK, fee_estimator: &LowerBoundedFeeEstimator<F>,
		logger: &L, hold_mon_update: bool,
	) -> Result<
		(
			Vec<(HTLCSource, PaymentHash)>,
			Vec<(StaticInvoice, BlindedMessagePath)>,
			Option<ChannelMonitorUpdate>,
		),
		ChannelError,
	> {
		if self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect(
				"Got revoke_and_ack message while quiescent".to_owned(),
			));
		}
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_)) {
			return Err(ChannelError::close(
				"Got revoke/ACK message when channel was not in an operational state".to_owned(),
			));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close(
				"Peer sent revoke_and_ack when we needed a channel_reestablish".to_owned(),
			));
		}
		if self.context.channel_state.is_both_sides_shutdown()
			&& self.context.last_sent_closing_fee.is_some()
		{
			return Err(ChannelError::close(
				"Peer sent revoke_and_ack after we'd started exchanging closing_signeds".to_owned(),
			));
		}

		let secret = secp_check!(
			SecretKey::from_slice(&msg.per_commitment_secret),
			"Peer provided an invalid per_commitment_secret".to_owned()
		);

		if let Some(counterparty_current_commitment_point) =
			self.context.counterparty_current_commitment_point
		{
			if PublicKey::from_secret_key(&self.context.secp_ctx, &secret)
				!= counterparty_current_commitment_point
			{
				return Err(ChannelError::close("Got a revoke commitment secret which didn't correspond to their current pubkey".to_owned()));
			}
		}

		if !self.context.channel_state.is_awaiting_remote_revoke() {
			// Our counterparty seems to have burned their coins to us (by revoking a state when we
			// haven't given them a new commitment transaction to broadcast). We should probably
			// take advantage of this by updating our channel monitor, sending them an error, and
			// waiting for them to broadcast their latest (now-revoked claim). But, that would be a
			// lot of work, and there's some chance this is all a misunderstanding anyway.
			// We have to do *something*, though, since our signer may get mad at us for otherwise
			// jumping a remote commitment number, so best to just force-close and move on.
			return Err(ChannelError::close("Received an unexpected revoke_and_ack".to_owned()));
		}

		self.context
			.holder_signer
			.validate_counterparty_revocation(
				self.context.counterparty_next_commitment_transaction_number + 1,
				&secret,
			)
			.map_err(|_| {
				ChannelError::close("Failed to validate revocation from peer".to_owned())
			})?;

		self.context
			.commitment_secrets
			.provide_secret(
				self.context.counterparty_next_commitment_transaction_number + 1,
				msg.per_commitment_secret,
			)
			.map_err(|_| {
				ChannelError::close("Previous secrets did not match new one".to_owned())
			})?;
		self.context.latest_monitor_update_id += 1;
		let mut monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![ChannelMonitorUpdateStep::CommitmentSecret {
				idx: self.context.counterparty_next_commitment_transaction_number + 1,
				secret: msg.per_commitment_secret,
			}],
			channel_id: Some(self.context.channel_id()),
		};

		// Update state now that we've passed all the can-fail calls...
		// (note that we may still fail to generate the new commitment_signed message, but that's
		// OK, we step the channel here and *then* if the new generation fails we can fail the
		// channel based on that, but stepping stuff here should be safe either way.
		self.context.channel_state.clear_awaiting_remote_revoke();
		self.mark_response_received();
		self.context.counterparty_current_commitment_point =
			self.context.counterparty_next_commitment_point;
		self.context.counterparty_next_commitment_point = Some(msg.next_per_commitment_point);
		self.context.counterparty_next_commitment_transaction_number -= 1;

		if self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
			self.context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
		}

		log_trace!(logger, "Updating HTLCs on receipt of RAA...");
		let mut to_forward_infos = Vec::new();
		let mut pending_update_adds = Vec::new();
		let mut revoked_htlcs = Vec::new();
		let mut finalized_claimed_htlcs = Vec::new();
		let mut update_fail_htlcs = Vec::new();
		let mut update_fail_malformed_htlcs = Vec::new();
		let mut static_invoices = Vec::new();
		let mut require_commitment = false;
		let mut value_to_self_msat_diff: i64 = 0;

		{
			// Take references explicitly so that we can hold multiple references to self.context.
			let pending_inbound_htlcs: &mut Vec<_> = &mut self.context.pending_inbound_htlcs;
			let pending_outbound_htlcs: &mut Vec<_> = &mut self.context.pending_outbound_htlcs;
			let expecting_peer_commitment_signed =
				&mut self.context.expecting_peer_commitment_signed;

			// We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
			pending_inbound_htlcs.retain(|htlc| {
				if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
					log_trace!(logger, " ...removing inbound LocalRemoved {}", &htlc.payment_hash);
					if let &InboundHTLCRemovalReason::Fulfill { .. } = reason {
						value_to_self_msat_diff += htlc.amount_msat as i64;
					}
					*expecting_peer_commitment_signed = true;
					false
				} else {
					true
				}
			});
			pending_outbound_htlcs.retain(|htlc| {
				if let &OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) = &htlc.state {
					log_trace!(
						logger,
						" ...removing outbound AwaitingRemovedRemoteRevoke {}",
						&htlc.payment_hash
					);
					// We really want take() here, but, again, non-mut ref :(
					match outcome.clone() {
						OutboundHTLCOutcome::Failure(mut reason) => {
							hold_time_since(htlc.send_timestamp).map(|hold_time| {
								reason.set_hold_time(hold_time);
							});
							revoked_htlcs.push((htlc.source.clone(), htlc.payment_hash, reason));
						},
						OutboundHTLCOutcome::Success { attribution_data, .. } => {
							// Even though a fast track was taken for fulfilled HTLCs to the incoming side, we still
							// pass along attribution data here so that we can include hold time information in the
							// final PaymentPathSuccessful events.
							finalized_claimed_htlcs.push((htlc.source.clone(), attribution_data));
							// They fulfilled, so we sent them money
							value_to_self_msat_diff -= htlc.amount_msat as i64;
						},
					}
					false
				} else {
					true
				}
			});
			for htlc in pending_inbound_htlcs.iter_mut() {
				let swap = if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) = &htlc.state
				{
					true
				} else if let &InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) = &htlc.state {
					true
				} else {
					false
				};
				if swap {
					let mut state =
						InboundHTLCState::Committed { update_add_htlc: InboundUpdateAdd::Legacy };
					mem::swap(&mut state, &mut htlc.state);

					if let InboundHTLCState::AwaitingRemoteRevokeToAnnounce(resolution) = state {
						log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", &htlc.payment_hash);
						htlc.state = InboundHTLCState::AwaitingAnnouncedRemoteRevoke(resolution);
						require_commitment = true;
					} else if let InboundHTLCState::AwaitingAnnouncedRemoteRevoke(resolution) =
						state
					{
						match resolution {
							InboundHTLCResolution::Resolved { pending_htlc_status } => {
								match pending_htlc_status {
									PendingHTLCStatus::Fail(fail_msg) => {
										log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to LocalRemoved due to PendingHTLCStatus indicating failure", &htlc.payment_hash);
										require_commitment = true;
										match fail_msg {
											HTLCFailureMsg::Relay(msg) => {
												htlc.state = InboundHTLCState::LocalRemoved(
													InboundHTLCRemovalReason::FailRelay(
														msg.clone().into(),
													),
												);
												update_fail_htlcs.push(msg)
											},
											HTLCFailureMsg::Malformed(msg) => {
												htlc.state = InboundHTLCState::LocalRemoved(
													InboundHTLCRemovalReason::FailMalformed {
														sha256_of_onion: msg.sha256_of_onion,
														failure_code: msg.failure_code,
													},
												);
												update_fail_malformed_htlcs.push(msg)
											},
										}
									},
									PendingHTLCStatus::Forward(forward_info) => {
										log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed, attempting to forward", &htlc.payment_hash);
										to_forward_infos.push((forward_info, htlc.htlc_id));
										htlc.state = InboundHTLCState::Committed {
											// HTLCs will only be in state `InboundHTLCResolution::Resolved` if they were
											// received on LDK 0.1-.
											update_add_htlc: InboundUpdateAdd::Legacy,
										};
									},
								}
							},
							InboundHTLCResolution::Pending { update_add_htlc } => {
								log_trace!(logger, " ...promoting inbound AwaitingAnnouncedRemoteRevoke {} to Committed", &htlc.payment_hash);
								pending_update_adds.push(update_add_htlc.clone());
								htlc.state = InboundHTLCState::Committed {
									update_add_htlc: InboundUpdateAdd::WithOnion {
										update_add_htlc,
									},
								};
							},
						}
					}
				}
			}
			for htlc in pending_outbound_htlcs.iter_mut() {
				for (htlc_id, blinded_path) in &msg.release_htlc_message_paths {
					if htlc.htlc_id != *htlc_id {
						continue;
					}
					let static_invoice = match htlc.source.static_invoice() {
						Some(inv) if htlc.hold_htlc.is_some() => inv,
						_ => {
							// We should only be using our counterparty's release_htlc_message_path if we
							// originally configured the HTLC to be held with them until the recipient comes
							// online. Otherwise, our counterparty could include paths for all of our HTLCs and
							// use the responses sent to their paths to determine which of our HTLCs are async
							// payments.
							log_trace!(logger, "Counterparty included release_htlc_message_path for non-async payment HTLC {}", htlc_id);
							continue;
						},
					};
					static_invoices.push((static_invoice, blinded_path.clone()));
				}
				if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
					log_trace!(
						logger,
						" ...promoting outbound LocalAnnounced {} to Committed",
						&htlc.payment_hash
					);
					htlc.state = OutboundHTLCState::Committed;
					*expecting_peer_commitment_signed = true;
				}
				if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) =
					&mut htlc.state
				{
					log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", &htlc.payment_hash);
					// Swap against a dummy variant to avoid a potentially expensive clone of `OutboundHTLCOutcome::Failure(HTLCFailReason)`
					let mut reason = OutboundHTLCOutcome::Success {
						preimage: PaymentPreimage([0u8; 32]),
						attribution_data: None,
					};
					mem::swap(outcome, &mut reason);
					htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
					require_commitment = true;
				}
			}
		}

		for funding in self.funding_and_pending_funding_iter_mut() {
			funding.value_to_self_msat =
				(funding.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
		}

		if let Some((feerate, update_state)) = self.context.pending_update_fee {
			match update_state {
				FeeUpdateState::Outbound => {
					debug_assert!(self.funding.is_outbound());
					log_trace!(
						logger,
						" ...promoting outbound fee update {} to Committed",
						feerate
					);
					self.context.feerate_per_kw = feerate;
					self.context.pending_update_fee = None;
					self.context.expecting_peer_commitment_signed = true;
				},
				FeeUpdateState::RemoteAnnounced => {
					debug_assert!(!self.funding.is_outbound());
				},
				FeeUpdateState::AwaitingRemoteRevokeToAnnounce => {
					debug_assert!(!self.funding.is_outbound());
					log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
					require_commitment = true;
					self.context.feerate_per_kw = feerate;
					self.context.pending_update_fee = None;
				},
			}
		}

		let release_monitor = self.context.blocked_monitor_updates.is_empty() && !hold_mon_update;
		let release_state_str = if hold_mon_update {
			"Holding"
		} else if release_monitor {
			"Releasing"
		} else {
			"Blocked"
		};
		macro_rules! return_with_htlcs_to_fail {
			($htlcs_to_fail: expr) => {
				if !release_monitor {
					self.context
						.blocked_monitor_updates
						.push(PendingChannelMonitorUpdate { update: monitor_update });
					return Ok(($htlcs_to_fail, static_invoices, None));
				} else {
					return Ok(($htlcs_to_fail, static_invoices, Some(monitor_update)));
				}
			};
		}

		self.context.monitor_pending_update_adds.append(&mut pending_update_adds);

		match self.maybe_free_holding_cell_htlcs(fee_estimator, logger) {
			(Some(mut additional_update), htlcs_to_fail) => {
				// free_holding_cell_htlcs may bump latest_monitor_id multiple times but we want them to be
				// strictly increasing by one, so decrement it here.
				self.context.latest_monitor_update_id = monitor_update.update_id;
				monitor_update.updates.append(&mut additional_update.updates);

				log_debug!(logger, "Received a valid revoke_and_ack with holding cell HTLCs freed. {} monitor update.",
					release_state_str);

				self.monitor_updating_paused(
					false,
					true,
					false,
					to_forward_infos,
					revoked_htlcs,
					finalized_claimed_htlcs,
					logger,
				);
				return_with_htlcs_to_fail!(htlcs_to_fail);
			},
			(None, htlcs_to_fail) => {
				if require_commitment {
					// We can't generate a new commitment transaction yet so we just return what we
					// have. When the monitor updating is restored we'll call
					// get_last_commitment_update_for_send(), which does not update state, but we're
					// definitely now awaiting a remote revoke before we can step forward any more,
					// so set it here.
					let mut additional_update = self.build_commitment_no_status_check(logger);

					// build_commitment_no_status_check may bump latest_monitor_id but we want them to be
					// strictly increasing by one, so decrement it here.
					self.context.latest_monitor_update_id = monitor_update.update_id;
					monitor_update.updates.append(&mut additional_update.updates);

					log_debug!(
						logger,
						"Received a valid revoke_and_ack. {} monitor update.",
						release_state_str
					);
					if self.context.channel_state.can_generate_new_commitment() {
						log_debug!(logger, "Responding with a commitment update with {} HTLCs failed for channel {}",
							update_fail_htlcs.len() + update_fail_malformed_htlcs.len(),
							&self.context.channel_id);
					} else {
						let reason = if self.context.channel_state.is_local_stfu_sent() {
							"exits quiescence"
						} else if self.context.channel_state.is_monitor_update_in_progress() {
							"completes pending monitor update"
						} else {
							"can continue progress"
						};
						log_debug!(logger, "Holding back commitment update until {}", reason);
					}

					self.monitor_updating_paused(
						false,
						true,
						false,
						to_forward_infos,
						revoked_htlcs,
						finalized_claimed_htlcs,
						logger,
					);
					return_with_htlcs_to_fail!(htlcs_to_fail);
				} else {
					log_debug!(logger, "Received a valid revoke_and_ack with no reply necessary. {} monitor update {}.",
						release_state_str, monitor_update.update_id);

					self.monitor_updating_paused(
						false,
						false,
						false,
						to_forward_infos,
						revoked_htlcs,
						finalized_claimed_htlcs,
						logger,
					);
					return_with_htlcs_to_fail!(htlcs_to_fail);
				}
			},
		}
	}

	fn on_tx_signatures_exchange<'a, L: Logger>(
		&mut self, funding_tx_signed: &mut FundingTxSigned, funding_tx: Transaction,
		best_block_height: u32, logger: &WithChannelContext<'a, L>,
	) {
		debug_assert!(
			!self.is_awaiting_monitor_update() || !self.context.monitor_pending_tx_signatures
		);
		debug_assert!(!self.context.is_waiting_on_peer_pending_channel_update());

		if self.pending_splice.is_some() {
			self.exit_quiescence();

			let pending_splice = self.pending_splice.as_mut().expect("We just checked it above");
			if let Some(FundingNegotiation::AwaitingSignatures {
				mut funding,
				funding_feerate_sat_per_1000_weight,
				..
			}) = pending_splice.funding_negotiation.take()
			{
				funding.funding_transaction = Some(funding_tx.clone());
				pending_splice.last_funding_feerate_sat_per_1000_weight =
					Some(funding_feerate_sat_per_1000_weight);

				let funding_txo =
					funding.get_funding_txo().expect("funding outpoint should be set");
				let channel_type = funding.get_channel_type().clone();
				let funding_redeem_script = funding.get_funding_redeemscript();
				let has_local_contribution = self
					.context
					.interactive_tx_signing_session
					.as_ref()
					.map(|signing_session| signing_session.has_local_contribution())
					.unwrap_or(false);

				let contribution = pending_splice.negotiation_contribution.take();
				pending_splice
					.negotiated_candidates
					.push(NegotiatedCandidate { funding, contribution });
				debug_assert!(
					pending_splice.contributions_form_suffix(),
					"a round following one we contributed to must carry our contribution",
				);

				let splice_negotiated = SpliceFundingNegotiated {
					funding_txo: funding_txo.into_bitcoin_outpoint(),
					has_local_contribution,
					channel_type,
					funding_redeem_script,
				};

				let splice_locked = pending_splice.check_get_splice_locked(
					&self.context,
					pending_splice.negotiated_candidates.len() - 1,
					best_block_height,
				);
				if let Some(splice_txid) =
					splice_locked.as_ref().map(|splice_locked| splice_locked.splice_txid)
				{
					log_info!(
						logger,
						"Sending 0conf splice_locked txid {} to our peer",
						splice_txid,
					);
				}

				let candidates = pending_splice
					.negotiated_candidates
					.iter()
					.map(|candidate| {
						let txid = candidate
							.funding
							.get_funding_txid()
							.expect("negotiated candidates should have a funding txid");
						FundingCandidate {
							txid,
							channels: vec![ChannelFunding {
								counterparty_node_id: self.context.counterparty_node_id,
								channel_id: self.context.channel_id,
								purpose: FundingPurpose::Splice,
								contribution: candidate.contribution.clone(),
							}],
						}
					})
					.collect();
				let tx_type = TransactionType::InteractiveFunding { candidates };
				funding_tx_signed.funding_tx = Some((funding_tx, tx_type));
				funding_tx_signed.splice_negotiated = Some(splice_negotiated);
				funding_tx_signed.splice_locked = splice_locked;
			} else {
				debug_assert!(false);
			}
		} else {
			self.funding.funding_transaction = Some(funding_tx.clone());
			self.context.channel_state =
				ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new());
			let tx_type = TransactionType::Funding {
				channels: vec![(self.context.counterparty_node_id, self.context.channel_id)],
			};
			funding_tx_signed.funding_tx = Some((funding_tx, tx_type));
		}
	}

	pub fn tx_signatures<L: Logger>(
		&mut self, msg: &msgs::TxSignatures, best_block_height: u32, logger: &L,
	) -> Result<FundingTxSigned, ChannelError> {
		let signing_session = if let Some(signing_session) =
			self.context.interactive_tx_signing_session.as_mut()
		{
			if signing_session.has_received_tx_signatures() {
				return Err(ChannelError::Ignore("Ignoring duplicate tx_signatures".to_owned()));
			}
			if !signing_session.has_received_commitment_signed() {
				return Err(ChannelError::close(
					"Received tx_signatures before initial commitment_signed".to_owned(),
				));
			}

			if let Some(pending_splice) = self.pending_splice.as_ref() {
				debug_assert!(pending_splice
					.funding_negotiation
					.as_ref()
					.map(|funding_negotiation| matches!(
						funding_negotiation,
						FundingNegotiation::AwaitingSignatures { .. }
					))
					.unwrap_or(false));
			}

			signing_session
		} else {
			return Err(ChannelError::Ignore("Ignoring unexpected tx_signatures".to_owned()));
		};

		if msg.tx_hash != signing_session.unsigned_tx().compute_txid() {
			let msg = "The txid for the transaction does not match";
			let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
			return Err(ChannelError::Close((msg.to_owned(), reason)));
		}

		for witness in &msg.witnesses {
			if witness.is_empty() {
				let msg = "Unexpected empty witness in tx_signatures received";
				let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
				return Err(ChannelError::Close((msg.to_owned(), reason)));
			}
		}

		let awaiting_holder_shared_input_signature =
			signing_session.awaiting_holder_shared_input_signature();
		let (holder_tx_signatures, funding_tx) =
			signing_session.received_tx_signatures(msg).map_err(|msg| ChannelError::Warn(msg))?;

		let logger = WithChannelContext::from(logger, &self.context, None);
		log_info!(
			logger,
			"Received tx_signatures for interactive funding transaction {}",
			msg.tx_hash
		);

		let mut funding_tx_signed = FundingTxSigned {
			commitment_signed: None,
			counterparty_initial_commitment_signed_result: None,
			tx_signatures: None,
			funding_tx: None,
			splice_negotiated: None,
			splice_locked: None,
		};
		if self.is_awaiting_monitor_update() && self.context.monitor_pending_tx_signatures {
			// Although the user may have already provided our `tx_signatures`, we must not send
			// them if we're waiting for the monitor to durably persist the counterparty's signature
			// for our initial commitment post-splice.
			debug_assert!(holder_tx_signatures.is_some());
			log_debug!(
				logger,
				"Waiting for async monitor update to complete prior to releasing our tx_signatures"
			);
			return Ok(funding_tx_signed);
		}

		funding_tx_signed.tx_signatures = holder_tx_signatures;
		if let Some(funding_tx) = funding_tx {
			self.on_tx_signatures_exchange(
				&mut funding_tx_signed,
				funding_tx,
				best_block_height,
				&logger,
			);
		} else if awaiting_holder_shared_input_signature {
			log_debug!(
				logger,
				"Waiting for funding transaction shared input signature before finalizing negotiation"
			);
		} else {
			debug_assert!(
				false,
				"Signed funding transaction should be available upon tx_signatures exchange"
			);
		}
		Ok(funding_tx_signed)
	}

	/// Queues up an outbound update fee by placing it in the holding cell. You should call
	/// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
	/// commitment update.
	pub fn queue_update_fee<F: FeeEstimator, L: Logger>(
		&mut self, feerate_per_kw: u32, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) {
		let msg_opt = self.send_update_fee(feerate_per_kw, true, fee_estimator, logger);
		assert!(msg_opt.is_none(), "We forced holding cell?");
	}

	/// Adds a pending update to this channel. See the doc for send_htlc for
	/// further details on the optionness of the return value.
	/// If our balance is too low to cover the cost of the next commitment transaction at the
	/// new feerate, the update is cancelled.
	///
	/// You MUST call [`Self::send_commitment_no_state_update`] prior to any other calls on this
	/// [`FundedChannel`] if `force_holding_cell` is false.
	#[rustfmt::skip]
	fn send_update_fee<F: FeeEstimator, L: Logger>(
		&mut self, feerate_per_kw: u32, mut force_holding_cell: bool,
		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
	) -> Option<msgs::UpdateFee> {
		if !self.funding.is_outbound() {
			panic!("Cannot send fee from inbound channel");
		}
		if !self.context.is_usable() {
			panic!("Cannot update fee until channel is fully established and we haven't started shutting down");
		}
		if !self.context.is_live() {
			panic!("Cannot update fee while peer is disconnected/we're awaiting a monitor update (ChannelManager should have caught this)");
		}

		// Sending a fee update for zero fee commitments will trigger a warning and disconnect
		// from our peer, but does not result in a loss of funds so we do not panic here.
		debug_assert!(!self.funding.get_channel_type().supports_anchor_zero_fee_commitments());

		let can_send_update_fee = core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.all(|funding| self.context.can_send_update_fee(funding, feerate_per_kw, fee_estimator, logger));
		if !can_send_update_fee {
			return None;
		}

		// Some of the checks of `can_generate_new_commitment` have already been done above, but
		// it's much more brittle to not use it in favor of checking the remaining flags left, as it
		// gives us one less code path to update if the method changes.
		if !self.context.channel_state.can_generate_new_commitment() {
			force_holding_cell = true;
		}

		if force_holding_cell {
			self.context.holding_cell_update_fee = Some(feerate_per_kw);
			return None;
		}

		debug_assert!(self.context.pending_update_fee.is_none());
		self.context.pending_update_fee = Some((feerate_per_kw, FeeUpdateState::Outbound));

		Some(msgs::UpdateFee {
			channel_id: self.context.channel_id,
			feerate_per_kw,
		})
	}

	/// Removes any uncommitted inbound HTLCs and resets the state of uncommitted outbound HTLC
	/// updates, to be used on peer disconnection. After this, update_*_htlc messages need to be
	/// resent.
	/// No further message handling calls may be made until a channel_reestablish dance has
	/// completed.
	/// May return `Err(())`, which implies [`ChannelContext::force_shutdown`] should be called immediately.
	#[rustfmt::skip]
	fn remove_uncommitted_htlcs_and_mark_paused<L: Logger>(&mut self, logger: &L) -> Result<(), ()> {
		assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
		if !self.context.can_resume_on_reconnect() {
			return Err(())
		}

		// We only clear `peer_disconnected` if we were able to reestablish the channel. We always
		// reset our awaiting response in case we failed reestablishment and are disconnecting.
		self.context.sent_message_awaiting_response = None;

		if self.context.channel_state.is_peer_disconnected() {
			// While the below code should be idempotent, it's simpler to just return early, as
			// redundant disconnect events can fire, though they should be rare.
			return Ok(());
		}

		if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent || self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
			self.context.announcement_sigs_state = AnnouncementSigsState::NotSent;
		}

		// Upon reconnect we have to start the closing_signed dance over, but shutdown messages
		// will be retransmitted.
		self.context.last_sent_closing_fee = None;
		self.context.pending_counterparty_closing_signed = None;
		self.context.closing_fee_limits = None;

		let mut inbound_drop_count = 0;
		self.context.pending_inbound_htlcs.retain(|htlc| {
			match htlc.state {
				InboundHTLCState::RemoteAnnounced(_) => {
					// They sent us an update_add_htlc but we never got the commitment_signed.
					// We'll tell them what commitment_signed we're expecting next and they'll drop
					// this HTLC accordingly
					inbound_drop_count += 1;
					false
				},
				InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_)|InboundHTLCState::AwaitingAnnouncedRemoteRevoke(_) => {
					// We received a commitment_signed updating this HTLC and (at least hopefully)
					// sent a revoke_and_ack (which we can re-transmit) and have heard nothing
					// in response to it yet, so don't touch it.
					true
				},
				InboundHTLCState::Committed { .. } => true,
				InboundHTLCState::LocalRemoved(_) => {
					// We (hopefully) sent a commitment_signed updating this HTLC (which we can
					// re-transmit if needed) and they may have even sent a revoke_and_ack back
					// (that we missed). Keep this around for now and if they tell us they missed
					// the commitment_signed we can re-transmit the update then.
					true
				},
			}
		});
		self.context.next_counterparty_htlc_id -= inbound_drop_count;

		if let Some((_, update_state)) = self.context.pending_update_fee {
			if update_state == FeeUpdateState::RemoteAnnounced {
				debug_assert!(!self.funding.is_outbound());
				self.context.pending_update_fee = None;
			}
		}

		for htlc in self.context.pending_outbound_htlcs.iter_mut() {
			if let OutboundHTLCState::RemoteRemoved(_) = htlc.state {
				// They sent us an update to remove this but haven't yet sent the corresponding
				// commitment_signed, we need to move it back to Committed and they can re-send
				// the update upon reconnection.
				htlc.state = OutboundHTLCState::Committed;
			}
		}

		self.context.channel_state.set_peer_disconnected();
		log_trace!(logger, "Peer disconnection resulted in {} remote-announced HTLC drops on channel {}", inbound_drop_count, &self.context.channel_id());
		Ok(())
	}

	/// Indicates that a ChannelMonitor update is in progress and has not yet been fully persisted.
	/// This must be called before we return the [`ChannelMonitorUpdate`] back to the
	/// [`ChannelManager`], which will call [`Self::monitor_updating_restored`] once the monitor
	/// update completes (potentially immediately).
	/// The messages which were generated with the monitor update must *not* have been sent to the
	/// remote end, and must instead have been dropped. They will be regenerated when
	/// [`Self::monitor_updating_restored`] is called.
	///
	/// [`ChannelManager`]: super::channelmanager::ChannelManager
	/// [`chain::Watch`]: crate::chain::Watch
	/// [`ChannelMonitorUpdateStatus::InProgress`]: crate::chain::ChannelMonitorUpdateStatus::InProgress
	fn monitor_updating_paused<L: Logger>(
		&mut self, resend_raa: bool, resend_commitment: bool, resend_channel_ready: bool,
		pending_forwards: Vec<(PendingHTLCInfo, u64)>,
		pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
		pending_finalized_claimed_htlcs: Vec<(HTLCSource, Option<AttributionData>)>, logger: &L,
	) {
		log_trace!(logger, "Pausing channel monitor updates");

		self.context.monitor_pending_revoke_and_ack |= resend_raa;
		self.context.monitor_pending_commitment_signed |= resend_commitment;
		self.context.monitor_pending_channel_ready |= resend_channel_ready;
		self.context.monitor_pending_forwards.extend(pending_forwards);
		self.context.monitor_pending_failures.extend(pending_fails);
		self.context.monitor_pending_finalized_fulfills.extend(pending_finalized_claimed_htlcs);
		self.context.channel_state.set_monitor_update_in_progress();
	}

	/// Indicates that the latest ChannelMonitor update has been committed by the client
	/// successfully and we should restore normal operation. Returns messages which should be sent
	/// to the remote side.
	#[rustfmt::skip]
	pub fn monitor_updating_restored<'a, L: Logger, NS: NodeSigner, CBP>(
		&mut self, logger: &WithChannelContext<'a, L>, node_signer: &NS, chain_hash: ChainHash,
		user_config: &UserConfig, best_block_height: u32, path_for_release_htlc: CBP
	) -> MonitorRestoreUpdates
	where
		CBP: Fn(u64) -> BlindedMessagePath
	{
		assert!(self.context.channel_state.is_monitor_update_in_progress());
		self.context.channel_state.clear_monitor_update_in_progress();
		assert_eq!(self.blocked_monitor_updates_pending(), 0);
		// Some cases below may not strictly require ChannelManager persistence, but we err on
		// the conservative side to avoid missing state changes.
		let mut requires_channel_manager_persistence = false;

		// We want to clear that the monitor update for our `tx_signatures` has completed, but
		// we may still need to hold back the message until it's ready to be sent.
		let mut tx_signatures = self
			.context
			.monitor_pending_tx_signatures
			.then(|| ())
			.and_then(|_| self.context.interactive_tx_signing_session.as_ref())
			.and_then(|signing_session| signing_session.holder_tx_signatures());
		self.context.monitor_pending_tx_signatures = false;

		let mut funding_tx_signed = None;
		if tx_signatures.is_some() {
			let signing_session = self.context.interactive_tx_signing_session.as_ref()
				.expect("We have a tx_signatures message so we must have a valid signing session");
			if self.context.signer_pending_funding {
				tx_signatures.take();
			} else {
				debug_assert!(tx_signatures.is_some());
				funding_tx_signed = Some(FundingTxSigned {
					commitment_signed: None,
					counterparty_initial_commitment_signed_result: None,
					tx_signatures,
					funding_tx: None,
					splice_negotiated: None,
					splice_locked: None,
				});
				requires_channel_manager_persistence = true;
				if let Some(funding_tx) = signing_session.signed_tx() {
					self.on_tx_signatures_exchange(
						funding_tx_signed.as_mut().unwrap(),
						funding_tx,
						best_block_height,
						logger,
					);
				} else if signing_session.has_received_tx_signatures() {
					debug_assert!(false, "Signed funding transaction should be available upon tx_signatures exchange");
				}
			}
		}

		// If we're past (or at) the AwaitingChannelReady stage on an outbound (or V2-established) channel,
		// try to (re-)broadcast the funding transaction as we may have declined to broadcast it when we
		// first received the funding_signed.
		let mut funding_broadcastable = None;
		if let Some(funding_transaction) = &self.funding.funding_transaction {
			if (self.funding.is_outbound() || self.is_v2_established()) &&
				(matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(flags) if !flags.is_set(AwaitingChannelReadyFlags::WAITING_FOR_BATCH)) ||
				matches!(self.context.channel_state, ChannelState::ChannelReady(_)))
			{
				// Broadcast only if not yet confirmed
				if self.funding.get_funding_tx_confirmation_height().is_none() {
					funding_broadcastable = Some(funding_transaction.clone());
					requires_channel_manager_persistence = true;
				}
			}
		}

		// An active interactive signing session or an awaiting channel_ready state implies that a
		// commitment_signed retransmission is an initial one for funding negotiation. Thus, the
		// signatures should be sent before channel_ready.
		let channel_ready_order = if self.context.interactive_tx_signing_session.is_some() {
			ChannelReadyOrder::SignaturesFirst
		} else if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(_)) {
			ChannelReadyOrder::SignaturesFirst
		} else {
			ChannelReadyOrder::ChannelReadyFirst
		};

		// We will never broadcast the funding transaction when we're in MonitorUpdateInProgress
		// (and we assume the user never directly broadcasts the funding transaction and waits for
		// us to do it). Thus, we can only ever hit monitor_pending_channel_ready when we're
		// * an inbound channel that failed to persist the monitor on funding_created and we got
		//   the funding transaction confirmed before the monitor was persisted, or
		// * a 0-conf channel and intended to send the channel_ready before any broadcast at all.
		let channel_ready = if self.context.monitor_pending_channel_ready {
			assert!(!self.funding.is_outbound() || self.context.minimum_depth == Some(0),
				"Funding transaction broadcast by the local client before it should have - LDK didn't do it!");
			self.context.monitor_pending_channel_ready = false;
			let channel_ready = self.get_channel_ready(logger);
			requires_channel_manager_persistence |= channel_ready.is_some();
			channel_ready
		} else { None };

		let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block_height, logger);
		requires_channel_manager_persistence |= announcement_sigs.is_some();

		let mut accepted_htlcs = Vec::new();
		mem::swap(&mut accepted_htlcs, &mut self.context.monitor_pending_forwards);
		requires_channel_manager_persistence |= !accepted_htlcs.is_empty();
		let mut failed_htlcs = Vec::new();
		mem::swap(&mut failed_htlcs, &mut self.context.monitor_pending_failures);
		requires_channel_manager_persistence |= !failed_htlcs.is_empty();
		let mut finalized_claimed_htlcs = Vec::new();
		mem::swap(&mut finalized_claimed_htlcs, &mut self.context.monitor_pending_finalized_fulfills);
		requires_channel_manager_persistence |= !finalized_claimed_htlcs.is_empty();
		let mut pending_update_adds = Vec::new();
		mem::swap(&mut pending_update_adds, &mut self.context.monitor_pending_update_adds);
		requires_channel_manager_persistence |= !pending_update_adds.is_empty();
		let committed_outbound_htlc_sources: Vec<(HTLCPreviousHopData, u64)> = self.context.pending_outbound_htlcs.iter().filter_map(|htlc| {
			if let &OutboundHTLCState::LocalAnnounced(_) = &htlc.state {
				if let HTLCSource::PreviousHopData(prev_hop_data) = &htlc.source {
					return Some((prev_hop_data.clone(), htlc.amount_msat))
				}
			}
			None
		}).collect();
		requires_channel_manager_persistence |= !committed_outbound_htlc_sources.is_empty();

		if self.context.channel_state.is_peer_disconnected() {
			self.context.monitor_pending_revoke_and_ack = false;
			self.context.monitor_pending_commitment_signed = false;
			return MonitorRestoreUpdates {
				raa: None, commitment_update: None, commitment_order: RAACommitmentOrder::RevokeAndACKFirst,
				accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, pending_update_adds,
				funding_broadcastable, channel_ready, channel_ready_order, announcement_sigs,
				funding_tx_signed, committed_outbound_htlc_sources,
				requires_channel_manager_persistence,
			};
		}

		let mut raa = if self.context.monitor_pending_revoke_and_ack {
			self.get_last_revoke_and_ack(path_for_release_htlc, logger)
		} else { None };
		let mut commitment_update = if self.context.monitor_pending_commitment_signed {
			self.get_last_commitment_update_for_send(logger).ok()
		} else { None };
		if self.context.resend_order == RAACommitmentOrder::CommitmentFirst
			&& self.context.signer_pending_commitment_update && raa.is_some() {
			self.context.signer_pending_revoke_and_ack = true;
			raa = None;
		}
		if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
			&& self.context.signer_pending_revoke_and_ack && commitment_update.is_some() {
			self.context.signer_pending_commitment_update = true;
			commitment_update = None;
		}

		self.context.monitor_pending_revoke_and_ack = false;
		self.context.monitor_pending_commitment_signed = false;
		let commitment_order = self.context.resend_order.clone();
		log_debug!(logger, "Restored monitor updating in channel {} resulting in {}{} commitment update and {} RAA, with {} first",
			&self.context.channel_id(), if funding_broadcastable.is_some() { "a funding broadcastable, " } else { "" },
			if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
			match commitment_order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
		MonitorRestoreUpdates {
			raa, commitment_update, commitment_order, accepted_htlcs, failed_htlcs, finalized_claimed_htlcs,
			pending_update_adds, funding_broadcastable, channel_ready, channel_ready_order,
			announcement_sigs, funding_tx_signed, committed_outbound_htlc_sources,
			requires_channel_manager_persistence,
		}
	}

	pub fn check_for_stale_feerate<L: Logger>(
		&mut self, logger: &L, min_feerate: u32,
	) -> Result<(), ClosureReason> {
		if self.funding.is_outbound() {
			// While its possible our fee is too low for an outbound channel because we've been
			// unable to increase the fee, we don't try to force-close directly here.
			return Ok(());
		}

		if self.funding.get_channel_type().supports_anchor_zero_fee_commitments() {
			debug_assert_eq!(self.context.feerate_per_kw, 0);
			return Ok(());
		}

		if self.context.feerate_per_kw < min_feerate {
			log_info!(logger,
				"Closing channel as feerate of {} is below required {} (the minimum required rate over the past day)",
				self.context.feerate_per_kw, min_feerate
			);
			Err(ClosureReason::PeerFeerateTooLow {
				peer_feerate_sat_per_kw: self.context.feerate_per_kw,
				required_feerate_sat_per_kw: min_feerate,
			})
		} else {
			Ok(())
		}
	}

	#[rustfmt::skip]
	pub fn update_fee<F: FeeEstimator, L: Logger>(&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::UpdateFee, logger: &L) -> Result<(), ChannelError> {
		if self.funding.is_outbound() {
			return Err(ChannelError::close("Non-funding remote tried to update channel fee".to_owned()));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close("Peer sent update_fee when we needed a channel_reestablish".to_owned()));
		}
		if self.context.channel_state.is_remote_stfu_sent() || self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Got fee update message while quiescent".to_owned()));
		}
		if self.funding.get_channel_type().supports_anchor_zero_fee_commitments() {
			return Err(ChannelError::WarnAndDisconnect("Update fee message received for zero fee commitment channel".to_owned()));
		}

		core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.try_for_each(|funding| FundedChannel::<SP>::check_remote_fee(funding.get_channel_type(), fee_estimator, msg.feerate_per_kw, Some(self.context.feerate_per_kw), logger))?;

		self.context.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
		self.context.update_time_counter += 1;
		Ok(())
	}

	/// Indicates that the signer may have some signatures for us, so we should retry if we're
	/// blocked.
	#[rustfmt::skip]
	pub fn signer_maybe_unblocked<L: Logger, CBP>(
		&mut self, best_block_height: u32, logger: &L, path_for_release_htlc: CBP
	) -> Result<SignerResumeUpdates, ChannelError> where CBP: Fn(u64) -> BlindedMessagePath {
		if let Some((commitment_number, commitment_secret)) = self.context.signer_pending_stale_state_verification.clone() {
			if let Ok(expected_point) = self
				.context
				.holder_signer
				.get_per_commitment_point(commitment_number, &self.context.secp_ctx)
			{
				self.context.signer_pending_stale_state_verification.take();
				if expected_point != PublicKey::from_secret_key(&self.context.secp_ctx, &commitment_secret) {
					return Err(ChannelError::close("Peer sent a channel_reestablish indicating we're stale with an invalid commitment secret".to_owned()));
				}
				Self::panic_on_stale_state(logger);
			}
		}
		if !self.holder_commitment_point.can_advance() {
			log_trace!(logger, "Attempting to update holder per-commitment point...");
			self.holder_commitment_point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
		}

		let funding_signed = if self.context.signer_pending_funding
			&& !self.is_v2_established()
			&& !self.funding.is_outbound()
			&& self.pending_splice.is_none()
		{
			let commitment_data = self.context.build_commitment_transaction(&self.funding,
				// The previous transaction number (i.e., when adding 1) is used because this field
				// is advanced when handling funding_created, but the point is not advanced until
				// handling channel_ready.
				self.context.counterparty_next_commitment_transaction_number + 1,
				&self.context.counterparty_next_commitment_point.unwrap(), false, false, logger);
			let counterparty_initial_commitment_tx = commitment_data.tx;
			self.context.get_funding_signed_msg(&self.funding.channel_transaction_parameters, logger, counterparty_initial_commitment_tx)
		} else { None };

		let funding_commit_sig = if self.context.signer_pending_funding
			&& (self.is_v2_established() || self.pending_splice.is_some())
		{
			log_debug!(logger, "Attempting to generate pending initial commitment_signed...");
			let funding = self
				.pending_splice
				.as_ref()
				.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
				.and_then(|funding_negotiation| {
					debug_assert!(matches!(
							funding_negotiation,
							FundingNegotiation::AwaitingSignatures { .. }
					));
					funding_negotiation.as_funding()
				})
				.unwrap_or(&self.funding);
			self.context.get_initial_commitment_signed_v2(funding, logger)
		} else {
			None
		};

		let mut shared_input_signature_unblocked = false;
		{
			if let Some(signing_session) = self.context.interactive_tx_signing_session.as_mut() {
				if signing_session.awaiting_holder_shared_input_signature() {
					let splice_input_index = signing_session
						.unsigned_tx()
						.shared_input_index()
						.expect("Missing shared input index while awaiting a splice signature");
					log_trace!(logger, "Attempting to generate pending splice shared input signature...");
					if let Ok(shared_input_signature) = self.context.holder_signer.sign_splice_shared_input(
						&self.funding.channel_transaction_parameters,
						signing_session.unsigned_tx().tx(),
						splice_input_index as usize,
						&self.context.secp_ctx,
					) {
						shared_input_signature_unblocked = true;
						signing_session
							.provide_holder_shared_input_signature(shared_input_signature)
							.map_err(ChannelError::close)?;
					}
				}
			}
		}

		let mut tx_signatures = None;
		let mut funding_tx = None;
		if funding_commit_sig.is_some() || shared_input_signature_unblocked {
			if let Some(signing_session) = self.context.interactive_tx_signing_session.as_ref() {
				if !self.is_awaiting_monitor_update() && !self.context.signer_pending_funding {
					tx_signatures = signing_session.holder_tx_signatures();
					funding_tx = tx_signatures.as_ref().and_then(|_| signing_session.signed_tx());
				}
			} else {
				debug_assert!(false);
			}
		}

		let mut funding_tx_signed = None;
		if funding_commit_sig.is_some() || tx_signatures.is_some() || funding_tx.is_some() {
			let mut resumed = FundingTxSigned {
				commitment_signed: funding_commit_sig,
				counterparty_initial_commitment_signed_result: None,
				tx_signatures,
				funding_tx: None,
				splice_negotiated: None,
				splice_locked: None,
			};
			if let Some(funding_tx) = funding_tx {
				let funding_logger = WithChannelContext::from(logger, &self.context, None);
				debug_assert!(resumed.tx_signatures.is_some());
				self.on_tx_signatures_exchange(
					&mut resumed,
					funding_tx,
					best_block_height,
					&funding_logger,
				);
			}
			funding_tx_signed = Some(resumed);
		}

		// Provide a `channel_ready` message if we need to, but only if we're _not_ still pending
		// funding.
		let channel_ready = if self.context.signer_pending_channel_ready && !self.context.signer_pending_funding {
			log_trace!(logger, "Attempting to generate pending channel_ready...");
			self.get_channel_ready(logger)
		} else { None };

		let mut commitment_update = if self.context.signer_pending_commitment_update {
			log_trace!(logger, "Attempting to generate pending commitment update...");
			self.get_last_commitment_update_for_send(logger).ok()
		} else { None };
		let mut revoke_and_ack = if self.context.signer_pending_revoke_and_ack {
			log_trace!(logger, "Attempting to generate pending revoke and ack...");
			self.get_last_revoke_and_ack(path_for_release_htlc, logger)
		} else { None };

		if self.context.resend_order == RAACommitmentOrder::CommitmentFirst
			&& self.context.signer_pending_commitment_update && revoke_and_ack.is_some() {
			log_trace!(logger, "Signer unblocked for revoke and ack, but unable to send due to resend order, waiting on signer for commitment update");
			self.context.signer_pending_revoke_and_ack = true;
			revoke_and_ack = None;
		}
		if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
			&& self.context.signer_pending_revoke_and_ack && commitment_update.is_some() {
			log_trace!(logger, "Signer unblocked for commitment update, but unable to send due to resend order, waiting on signer for revoke and ack");
			self.context.signer_pending_commitment_update = true;
			commitment_update = None;
		}
		if revoke_and_ack.is_some() {
			// If signer-pending state regenerated an RAA, the monitor update for that RAA was
			// already persisted before we set `signer_pending_revoke_and_ack`. Thus, if reconnect
			// also marked the same RAA monitor-pending while another monitor update was in flight,
			// the RAA we're returning here satisfies that monitor-pending resend.
			self.context.monitor_pending_revoke_and_ack = false;
		}

		let (closing_signed, signed_closing_tx, shutdown_result) = if self.context.signer_pending_closing {
			debug_assert!(self.context.last_sent_closing_fee.is_some());
			if let Some((fee, skip_remote_output, fee_range, holder_sig)) = self.context.last_sent_closing_fee.clone() {
				debug_assert!(holder_sig.is_none());
				log_trace!(logger, "Attempting to generate pending closing_signed...");
				let closing_transaction_result = self.build_closing_transaction(fee, skip_remote_output);
				match closing_transaction_result {
					Ok((closing_tx, fee)) => {
						let closing_signed = self.get_closing_signed_msg(&closing_tx, skip_remote_output,
																		 fee, fee_range.min_fee_satoshis, fee_range.max_fee_satoshis, logger);
						let signed_tx = if let (Some(ClosingSigned { signature, .. }), Some(counterparty_sig)) =
							(closing_signed.as_ref(), self.context.last_received_closing_sig) {
							let funding_redeemscript = self.funding.get_funding_redeemscript();
							let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.funding.get_value_satoshis());
							debug_assert!(self.context.secp_ctx.verify_ecdsa(&sighash, &counterparty_sig,
																			 &self.funding.get_counterparty_pubkeys().funding_pubkey).is_ok());
							Some(self.build_signed_closing_transaction(&closing_tx, &counterparty_sig, signature))
						} else { None };
						let shutdown_result = signed_tx.as_ref().map(|_| self.shutdown_result_coop_close());
						(closing_signed, signed_tx, shutdown_result)
					}
					Err(err) => {
						let shutdown = self.context.force_shutdown(&self.funding, ClosureReason::ProcessingError {err: err.to_string()});
						(None, None, Some(shutdown))
					}
				}
			} else { (None, None, None) }
		} else { (None, None, None) };

		log_trace!(logger, "Signer unblocked with {} commitment_update, {} revoke_and_ack, with resend order {:?}, {} funding_signed, \
			{} funding commit_sig, {} tx_signatures, {} channel_ready, {} closing_signed, {} signed_closing_tx, and {} shutdown result",
			if commitment_update.is_some() { "a" } else { "no" },
			if revoke_and_ack.is_some() { "a" } else { "no" },
			self.context.resend_order,
			if funding_signed.is_some() { "a" } else { "no" },
			if funding_tx_signed.as_ref().map(|v| v.commitment_signed.is_some()).unwrap_or(false) { "a" } else { "no" },
			if funding_tx_signed.as_ref().map(|v| v.tx_signatures.is_some()).unwrap_or(false) { "a" } else { "no" },
			if channel_ready.is_some() { "a" } else { "no" },
			if closing_signed.is_some() { "a" } else { "no" },
			if signed_closing_tx.is_some() { "a" } else { "no" },
			if shutdown_result.is_some() { "a" } else { "no" });

		Ok(SignerResumeUpdates {
			commitment_update,
			revoke_and_ack,
			open_channel: None,
			accept_channel: None,
			funding_created: None,
			funding_signed,
			funding_tx_signed,
			channel_ready,
			order: self.context.resend_order.clone(),
			closing_signed,
			signed_closing_tx,
			shutdown_result,
		})
	}

	fn get_last_revoke_and_ack<CBP, L: Logger>(
		&mut self, path_for_release_htlc: CBP, logger: &L,
	) -> Option<msgs::RevokeAndACK>
	where
		CBP: Fn(u64) -> BlindedMessagePath,
	{
		debug_assert!(
			self.holder_commitment_point.next_transaction_number() <= INITIAL_COMMITMENT_NUMBER - 2
		);
		let signer = &self.context.holder_signer;
		self.holder_commitment_point.try_resolve_pending(signer, &self.context.secp_ctx, logger);
		let per_commitment_secret = signer
			.release_commitment_secret(self.holder_commitment_point.next_transaction_number() + 2)
			.ok();
		if let Some(per_commitment_secret) = per_commitment_secret {
			if self.holder_commitment_point.can_advance() {
				let mut release_htlc_message_paths = Vec::new();
				for htlc in &self.context.pending_inbound_htlcs {
					if htlc.state.should_hold_htlc() {
						let path = path_for_release_htlc(htlc.htlc_id);
						release_htlc_message_paths.push((htlc.htlc_id, path));
					}
				}

				self.context.signer_pending_revoke_and_ack = false;
				return Some(msgs::RevokeAndACK {
					channel_id: self.context.channel_id,
					per_commitment_secret,
					next_per_commitment_point: self.holder_commitment_point.next_point(),
					release_htlc_message_paths,
				});
			}
		}
		if !self.holder_commitment_point.can_advance() {
			log_trace!(logger, "Last revoke-and-ack pending for sequence {} because the next per-commitment point is not available",
				self.holder_commitment_point.next_transaction_number());
		}
		if per_commitment_secret.is_none() {
			log_trace!(logger, "Last revoke-and-ack pending for sequence {} because the next per-commitment secret for {} is not available",
				self.holder_commitment_point.next_transaction_number(),
				self.holder_commitment_point.next_transaction_number() + 2);
		}
		// Technically if HolderCommitmentPoint::can_advance is false,
		// we have a commitment point ready to send in an RAA, however we
		// choose to wait since if we send RAA now, we could get another
		// CS before we have any commitment point available. Blocking our
		// RAA here is a convenient way to make sure that post-funding
		// we're only ever waiting on one commitment point at a time.
		log_trace!(logger, "Last revoke-and-ack pending for sequence {} because the next per-commitment point is not available",
			self.holder_commitment_point.next_transaction_number());
		self.context.signer_pending_revoke_and_ack = true;
		None
	}

	/// Gets the last commitment update for immediate sending to our peer.
	fn get_last_commitment_update_for_send<L: Logger>(
		&mut self, logger: &L,
	) -> Result<msgs::CommitmentUpdate, ()> {
		let mut update_add_htlcs = Vec::new();
		let mut update_fulfill_htlcs = Vec::new();
		let mut update_fail_htlcs = Vec::new();
		let mut update_fail_malformed_htlcs = Vec::new();

		for htlc in self.context.pending_outbound_htlcs.iter() {
			if let &OutboundHTLCState::LocalAnnounced(ref onion_packet) = &htlc.state {
				update_add_htlcs.push(msgs::UpdateAddHTLC {
					channel_id: self.context.channel_id(),
					htlc_id: htlc.htlc_id,
					amount_msat: htlc.amount_msat,
					payment_hash: htlc.payment_hash,
					cltv_expiry: htlc.cltv_expiry,
					onion_routing_packet: (**onion_packet).clone(),
					skimmed_fee_msat: htlc.skimmed_fee_msat,
					blinding_point: htlc.blinding_point,
					hold_htlc: htlc.hold_htlc,
					accountable: Some(htlc.accountable),
				});
			}
		}

		for htlc in self.context.pending_inbound_htlcs.iter() {
			if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
				match reason {
					&InboundHTLCRemovalReason::FailRelay(ref err_packet) => {
						update_fail_htlcs.push(msgs::UpdateFailHTLC {
							channel_id: self.context.channel_id(),
							htlc_id: htlc.htlc_id,
							reason: err_packet.data.clone(),
							attribution_data: err_packet.attribution_data.clone(),
						});
					},
					&InboundHTLCRemovalReason::FailMalformed {
						sha256_of_onion: ref hash,
						failure_code: ref code,
					} => {
						update_fail_malformed_htlcs.push(msgs::UpdateFailMalformedHTLC {
							channel_id: self.context.channel_id(),
							htlc_id: htlc.htlc_id,
							sha256_of_onion: hash.clone(),
							failure_code: code.clone(),
						});
					},
					&InboundHTLCRemovalReason::Fulfill { ref preimage, ref attribution_data } => {
						update_fulfill_htlcs.push(msgs::UpdateFulfillHTLC {
							channel_id: self.context.channel_id(),
							htlc_id: htlc.htlc_id,
							payment_preimage: preimage.clone(),
							attribution_data: attribution_data.clone(),
						});
					},
				}
			}
		}

		let update_fee = if self.funding.is_outbound() && self.context.pending_update_fee.is_some()
		{
			Some(msgs::UpdateFee {
				channel_id: self.context.channel_id(),
				feerate_per_kw: self.context.pending_update_fee.unwrap().0,
			})
		} else {
			None
		};

		log_trace!(logger, "Regenerating latest commitment update with{} {} update_adds, {} update_fulfills, {} update_fails, and {} update_fail_malformeds",
				if update_fee.is_some() { " update_fee," } else { "" },
				update_add_htlcs.len(), update_fulfill_htlcs.len(), update_fail_htlcs.len(), update_fail_malformed_htlcs.len());
		let commitment_signed = if let Ok(update) = self.send_commitment_no_state_update(logger) {
			if self.context.signer_pending_commitment_update {
				log_trace!(
					logger,
					"Commitment update generated: clearing signer_pending_commitment_update"
				);
				self.context.signer_pending_commitment_update = false;
			}
			update
		} else {
			if !self.context.signer_pending_commitment_update {
				log_trace!(
					logger,
					"Commitment update awaiting signer: setting signer_pending_commitment_update"
				);
				self.context.signer_pending_commitment_update = true;
			}
			return Err(());
		};
		Ok(msgs::CommitmentUpdate {
			update_add_htlcs,
			update_fulfill_htlcs,
			update_fail_htlcs,
			update_fail_malformed_htlcs,
			update_fee,
			commitment_signed,
		})
	}

	/// Gets the `Shutdown` message we should send our peer on reconnect, if any.
	pub fn get_outbound_shutdown(&self) -> Option<msgs::Shutdown> {
		if self.context.channel_state.is_local_shutdown_sent() {
			assert!(self.context.shutdown_scriptpubkey.is_some());
			Some(msgs::Shutdown {
				channel_id: self.context.channel_id,
				scriptpubkey: self.get_closing_scriptpubkey(),
			})
		} else {
			None
		}
	}

	fn panic_on_stale_state<L: Logger>(logger: &L) {
		macro_rules! log_and_panic {
			($err_msg: expr) => {
				log_error!(logger, $err_msg);
				panic!($err_msg);
			};
		}
		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\
			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\
			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\
			If you have restored from an old backup and wish to claim any available funds, you should restart with\n\
			an empty ChannelManager and no ChannelMonitors, reconnect to peer(s), ensure they've force-closed all of your\n\
			previous channels and that the closure transaction(s) have confirmed on-chain,\n\
			then restart with an empty ChannelManager and the latest ChannelMonitors that you do have.");
	}

	/// May panic if some calls other than message-handling calls (which will all Err immediately)
	/// have been called between remove_uncommitted_htlcs_and_mark_paused and this call.
	#[rustfmt::skip]
	pub fn channel_reestablish<L: Logger, NS: NodeSigner, CBP>(
		&mut self, msg: &msgs::ChannelReestablish, logger: &L, node_signer: &NS,
		chain_hash: ChainHash, user_config: &UserConfig, best_block: &BlockLocator,
		path_for_release_htlc: CBP,
	) -> Result<ReestablishResponses, ChannelError>
	where
		CBP: Fn(u64) -> BlindedMessagePath
	{
		if !self.context.channel_state.is_peer_disconnected() {
			// While BOLT 2 doesn't indicate explicitly we should error this channel here, it
			// almost certainly indicates we are going to end up out-of-sync in some way, so we
			// just close here instead of trying to recover.
			return Err(ChannelError::close("Peer sent a loose channel_reestablish not after reconnect".to_owned()));
		}

		// A node:
		//   - if `next_commitment_number` is zero:
		//     - MUST immediately fail the channel and broadcast any relevant latest commitment
		//       transaction.
		if msg.next_local_commitment_number == 0
			|| msg.next_local_commitment_number >= INITIAL_COMMITMENT_NUMBER
			|| msg.next_remote_commitment_number >= INITIAL_COMMITMENT_NUMBER
		{
			return Err(ChannelError::close("Peer sent an invalid channel_reestablish to force close in a non-standard way".to_owned()));
		}

		let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.current_transaction_number();
		if msg.next_remote_commitment_number > 0 {
			let given_secret = SecretKey::from_slice(&msg.your_last_per_commitment_secret)
				.map_err(|_| ChannelError::close("Peer sent a garbage channel_reestablish with unparseable secret key".to_owned()))?;
			if msg.next_remote_commitment_number > our_commitment_transaction {
				let given_commitment_number = INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1;
				let expected_point = self.context.holder_signer
					.get_per_commitment_point(given_commitment_number, &self.context.secp_ctx)
					.ok();
				if expected_point.is_none() {
					self.context.signer_pending_stale_state_verification = Some((given_commitment_number, given_secret));
					log_info!(logger, "Waiting on async signer to verify stale state proof");
					return Err(ChannelError::WarnAndDisconnect("Channel is not ready to be reestablished yet".to_owned()));
				}
				if expected_point != Some(PublicKey::from_secret_key(&self.context.secp_ctx, &given_secret)) {
					return Err(ChannelError::close("Peer sent a channel_reestablish indicating we're stale with an invalid commitment secret".to_owned()));
				}
				Self::panic_on_stale_state(logger);
			} else if msg.next_remote_commitment_number == our_commitment_transaction {
				let expected_point = self.holder_commitment_point.last_revoked_point()
					.expect("The last revoked commitment point must exist when the state has advanced");
				if expected_point != PublicKey::from_secret_key(&self.context.secp_ctx, &given_secret) {
					return Err(ChannelError::close("Peer sent a garbage channel_reestablish with secret key not matching the commitment height provided".to_owned()));
				}
			} else if msg.next_remote_commitment_number + 1 == our_commitment_transaction {
				let expected_point = self.holder_commitment_point.previous_revoked_point()
					.expect("The previous revoked commitment point must exist when they are one state behind");
				if expected_point != PublicKey::from_secret_key(&self.context.secp_ctx, &given_secret) {
					return Err(ChannelError::close("Peer sent a garbage channel_reestablish with secret key not matching the commitment height provided".to_owned()));
				}
			}
		}

		// Before we change the state of the channel, we check if the peer is sending a very old
		// commitment transaction number, if yes we send a warning message.
		if msg.next_remote_commitment_number + 1 < our_commitment_transaction {
			return Err(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
			)));
		}

		// Go ahead and unmark PeerDisconnected as various calls we may make check for it (and all
		// remaining cases either succeed or ErrorMessage-fail).
		self.context.channel_state.clear_peer_disconnected();
		self.mark_response_received();
		let funding_locked_txid_sent_in_reestablish =
			self.context.funding_locked_txid_sent_in_reestablish.take();

		let shutdown_msg = self.get_outbound_shutdown();

		// A receiving node:
		//   - if `my_current_funding_locked` is included with the `announcement_signatures` bit
		//     set in the `retransmit_flags`:
		//     - if `announce_channel` is set for this channel and the receiving node is ready
		//       to send `announcement_signatures` for the corresponding splice transaction:
		//       - MUST retransmit `announcement_signatures`.
		if let Some(funding_locked) = &msg.my_current_funding_locked {
			if funding_locked.should_retransmit(msgs::FundingLockedFlags::AnnouncementSignatures) {
				if self.funding.get_funding_txid() == Some(funding_locked.txid) {
					self.context.announcement_sigs_state = AnnouncementSigsState::NotSent;
				}
			}
		}

		// If the counterparty's `my_current_funding_locked` matches the splice we've already
		// confirmed and are about to promote, any `announcement_signatures` we'd generate here
		// would be for the soon-to-be-superseded pre-splice funding. Skip them;
		// `maybe_promote_splice_funding` will emit correct post-splice sigs once
		// `inferred_splice_locked` is processed.
		let our_splice_txid =
			self.pending_splice.as_ref().and_then(|pending| pending.sent_funding_txid);
		let splice_promotion_pending = msg
			.my_current_funding_locked
			.as_ref()
			.map(|funding_locked| Some(funding_locked.txid) == our_splice_txid)
			.unwrap_or(false);
		let announcement_sigs = if splice_promotion_pending {
			None
		} else {
			self.get_announcement_sigs(node_signer, chain_hash, user_config, best_block.height, logger)
		};

		let mut commitment_update = None;
		let mut tx_signatures = None;
		let mut tx_abort = None;

		// A receiving node:
		//   - if the `next_funding` TLV is set:
		let mut retransmit_funding_commit_sig = None;
		if let Some(next_funding) = &msg.next_funding {
			// - if `next_funding_txid` matches the latest interactive funding transaction
			//   or the current channel funding transaction:
			if let Some(session) = &self.context.interactive_tx_signing_session {
				let our_next_funding_txid = session.unsigned_tx().compute_txid();
				if our_next_funding_txid != next_funding.txid {
					if !session.has_received_tx_signatures() {
						return Err(ChannelError::close(format!(
							"Unexpected next_funding txid: {}; expected: {}",
							next_funding.txid, our_next_funding_txid,
						)));
					}
					tx_abort = Some(msgs::TxAbort {
						channel_id: self.context.channel_id(),
						data: format!("Unknown funding with txid {}", next_funding.txid).as_bytes().to_vec(),
					});
				} else if !session.has_holder_witnesses() {
					log_debug!(logger, "Waiting for funding transaction signatures to be provided");
				} else {
					// - if it has not received `tx_signatures` for that funding transaction:
					//   - if the `commitment_signed` bit is set in `retransmit_flags`:
					if !session.has_received_tx_signatures()
						&& next_funding.should_retransmit(msgs::NextFundingFlag::CommitmentSigned)
					{
						// - MUST retransmit its `commitment_signed` for that funding transaction.
						retransmit_funding_commit_sig = Some(next_funding.txid);
					}

					// - if it has already received `commitment_signed` and it should sign first
					//   - MUST send its `tx_signatures` for that funding transaction.
					//
					// - if it has already received `tx_signatures` for that funding transaction:
					//   - MUST send its `tx_signatures` for that funding transaction.
					if let Some(holder_tx_signatures) = session.holder_tx_signatures() {
						// A completed exchange may precede an unrelated monitor update, so
						// retransmitting the same signatures does not depend on that update.
						let splice_signatures_exchange_complete = self
							.pending_splice
							.as_ref()
							.map(|pending_splice| {
								pending_splice.negotiated_candidates.iter().any(|candidate| {
									candidate.funding.get_funding_txid() == Some(next_funding.txid)
								})
							})
							.unwrap_or(false);
						if self.is_awaiting_monitor_update()
							&& !splice_signatures_exchange_complete
						{
							log_debug!(logger, "Waiting for monitor update before providing funding transaction signatures");
						} else if self.context.signer_pending_funding {
							log_debug!(logger, "Waiting for signer to provide counterparty commitment_signed before releasing funding transaction signatures");
						} else {
							tx_signatures = Some(holder_tx_signatures);
						}
					}
				}
			} else {
				// We'll just send a `tx_abort` here if we don't have a signing session for this channel
				// on reestablish and tell our peer to just forget about it.
				// Our peer is doing something strange, but it doesn't warrant closing the channel.
				tx_abort = Some(msgs::TxAbort {
					channel_id: self.context.channel_id(),
					data:
						"Signing was not completed for this funding transaction; it may be forgotten.".as_bytes().to_vec() });
			}
		}
		if let Some(funding_txid) = retransmit_funding_commit_sig {
			let funding = self
				.pending_splice
				.as_ref()
				.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
				.and_then(|funding_negotiation| {
					if let FundingNegotiation::AwaitingSignatures { funding, .. } = &funding_negotiation {
						Some(funding)
					} else {
						None
					}
				})
				.or_else(|| Some(&self.funding))
				.filter(|funding| funding.get_funding_txid() == Some(funding_txid))
				.ok_or_else(|| {
					let message = "Failed to find funding for new commitment_signed".to_owned();
					ChannelError::Close(
						(
							message.clone(),
							ClosureReason::HolderForceClosed { message, broadcasted_latest_txn: Some(false) },
						)
					)
				})?;

			commitment_update = self
				.context
				.get_initial_commitment_signed_v2(&funding, logger)
				.map(|commitment_signed|
					msgs::CommitmentUpdate {
						commitment_signed: vec![commitment_signed],
						update_add_htlcs: vec![],
						update_fulfill_htlcs: vec![],
						update_fail_htlcs: vec![],
						update_fail_malformed_htlcs: vec![],
						update_fee: None,
					}
				);
			if commitment_update.is_none() {
				tx_signatures.take();
			}
		}

		if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(_)) {
			// If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
			if !self.context.channel_state.is_our_channel_ready() ||
					self.context.channel_state.is_monitor_update_in_progress() {
				if msg.next_remote_commitment_number != 0 {
					return Err(ChannelError::close("Peer claimed they saw a revoke_and_ack but we haven't sent channel_ready yet".to_owned()));
				}

				return Ok(ReestablishResponses {
					channel_ready: None,
					channel_ready_order: ChannelReadyOrder::SignaturesFirst,
					raa: None, commitment_update,
					commitment_order: self.context.resend_order.clone(),
					shutdown_msg, announcement_sigs,
					tx_signatures: tx_signatures
						.map(|msg| (TxSignaturesOrder::CommitmentFirst, msg)),
					tx_abort: None,
					splice_locked: None,
					inferred_splice_locked: None,
				});
			}

			// We have OurChannelReady set!
			return Ok(ReestablishResponses {
				channel_ready: self.get_channel_ready(logger),
				channel_ready_order: ChannelReadyOrder::SignaturesFirst,
				raa: None, commitment_update,
				commitment_order: self.context.resend_order.clone(),
				shutdown_msg, announcement_sigs,
				tx_signatures: tx_signatures
					.map(|msg| (TxSignaturesOrder::CommitmentFirst, msg)),
				tx_abort,
				splice_locked: None,
				inferred_splice_locked: None,
			});
		}

		let required_revoke = if msg.next_remote_commitment_number == our_commitment_transaction {
			// Remote isn't waiting on any RevokeAndACK from us!
			// Note that if we need to repeat our ChannelReady we'll do that in the next if block.
			// If a stale ChannelManager replayed a completed update, the monitor-pending state may
			// still think we owe one; the reestablish proof is authoritative here.
			self.context.monitor_pending_revoke_and_ack = false;
			None
		} else if msg.next_remote_commitment_number + 1 == our_commitment_transaction {
			if self.context.channel_state.is_monitor_update_in_progress() {
				self.context.monitor_pending_revoke_and_ack = true;
				None
			} else {
				self.get_last_revoke_and_ack(path_for_release_htlc, logger)
			}
		} else {
			debug_assert!(false, "All values should have been handled in the four cases above");
			return Err(ChannelError::close(format!(
				"Peer attempted to reestablish channel expecting a future local commitment transaction: {} (received) vs {} (expected)",
				msg.next_remote_commitment_number,
				our_commitment_transaction
			)));
		};

		// We increment counterparty_next_commitment_transaction_number only upon receipt of
		// revoke_and_ack, not on sending commitment_signed, so we add one if have
		// AwaitingRemoteRevoke set, which indicates we sent a commitment_signed but haven't gotten
		// the corresponding revoke_and_ack back yet.
		let is_awaiting_remote_revoke = self.context.channel_state.is_awaiting_remote_revoke();
		let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.context.counterparty_next_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };

		// A node:
		//   - if `next_commitment_number` is 1 in both the `channel_reestablish` it
		//     sent and received, and none of those `channel_reestablish` messages
		//     contain `my_current_funding_locked` or `next_funding` for a splice transaction:
		//     - MUST retransmit `channel_ready`.
		//   - otherwise:
		//     - MUST NOT retransmit `channel_ready`, but MAY send `channel_ready` with
		//       a different `short_channel_id` `alias` field.
		let both_sides_on_initial_commitment_number = msg.next_local_commitment_number == 1
			&& INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.next_transaction_number() == 1;
		let channel_ready = if both_sides_on_initial_commitment_number
			&& self.pending_splice.is_none()
			&& self.funding.channel_transaction_parameters.splice_parent_funding_txid.is_none()
		{
			// We should never have to worry about MonitorUpdateInProgress resending ChannelReady
			self.get_channel_ready(logger)
		} else { None };

		// A receiving node:
		//   - if splice transactions are pending and `my_current_funding_locked` matches one of
		//     those splice transactions, for which it hasn't received `splice_locked` yet:
		//     - MUST process `my_current_funding_locked` as if it was receiving `splice_locked`
		//       for this `txid`.
		let inferred_splice_locked = msg.my_current_funding_locked.as_ref().and_then(|funding_locked| {
			self.pending_funding()
				.find(|funding| funding.get_funding_txid() == Some(funding_locked.txid))
				.and_then(|_| {
					self.pending_splice.as_ref().and_then(|pending_splice| {
						(Some(funding_locked.txid) != pending_splice.received_funding_txid)
							.then(|| funding_locked.txid)
					})
				})
				.map(|splice_txid| msgs::SpliceLocked {
					channel_id: self.context.channel_id,
					splice_txid,
				})
		});
		let splice_locked = self.pending_splice.as_ref().and_then(|pending_splice| {
			pending_splice
				.sent_funding_txid
				.filter(|splice_txid| {
					// `my_current_funding_locked` normally makes an explicit retransmission
					// redundant. However, if the peer is still missing our `tx_signatures` for
					// this splice, it cannot recognize the locked funding until those signatures
					// arrive, so repeat `splice_locked` immediately afterwards.
					Some(*splice_txid) != funding_locked_txid_sent_in_reestablish
						|| tx_signatures
							.as_ref()
							.is_some_and(|tx_signatures| tx_signatures.tx_hash == *splice_txid)
				})
				.map(|splice_txid| msgs::SpliceLocked {
					channel_id: self.context.channel_id,
					splice_txid,
				})
		}).or_else(|| {
			// If a splice confirms after we've sent `channel_reestablish` but before we've received
			// theirs, we may promote the splice and clear `pending_splice`. We still need to send
			// `splice_locked` after reestablishing as it was not included in our
			// `channel_reestablish`.
			let current_funding_txid = self.funding.get_funding_txid()?;
			(self.pending_splice.is_none()
				&& self.funding.channel_transaction_parameters.splice_parent_funding_txid.is_some()
				&& Some(current_funding_txid) != funding_locked_txid_sent_in_reestablish)
				.then(|| msgs::SpliceLocked {
					channel_id: self.context.channel_id,
					splice_txid: current_funding_txid,
				})
		});

		if msg.next_local_commitment_number == next_counterparty_commitment_number {
			// If a stale ChannelManager replayed a completed update, the monitor-pending state may
			// still think we owe one.
			self.context.monitor_pending_commitment_signed = false;
			if required_revoke.is_some() || self.context.signer_pending_revoke_and_ack {
				log_debug!(logger, "Reconnected with only lost outbound RAA");
			} else {
				log_debug!(logger, "Reconnected with no loss");
			}

			// A commitment update generated above retransmits the initial splice
			// `commitment_signed` and must precede its funding signatures. Otherwise a completed
			// exchange's retransmitted signatures must precede any `splice_locked` below.
			let tx_signatures_order = if commitment_update.is_some() {
				TxSignaturesOrder::CommitmentFirst
			} else {
				TxSignaturesOrder::SignaturesFirst
			};

			Ok(ReestablishResponses {
				channel_ready,
				channel_ready_order: ChannelReadyOrder::SignaturesFirst,
				shutdown_msg,
				announcement_sigs,
				raa: required_revoke,
				commitment_update,
				commitment_order: self.context.resend_order.clone(),
				tx_signatures: tx_signatures.map(|msg| (tx_signatures_order, msg)),
				tx_abort,
				splice_locked,
				inferred_splice_locked,
			})
		} else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1
			&& is_awaiting_remote_revoke
		{
			if retransmit_funding_commit_sig.is_some() {
				return Err(ChannelError::close(
					"Peer requested retransmission of an initial commitment_signed while claiming to have lost a later commitment_signed".to_owned(),
				));
			}

			if required_revoke.is_some() || self.context.signer_pending_revoke_and_ack {
				log_debug!(logger, "Reconnected channel with lost outbound RAA and lost remote commitment tx");
			} else {
				log_debug!(logger, "Reconnected channel with only lost remote commitment tx");
			}

			if self.context.channel_state.is_monitor_update_in_progress() {
				self.context.monitor_pending_commitment_signed = true;
				Ok(ReestablishResponses {
					channel_ready,
					channel_ready_order: ChannelReadyOrder::ChannelReadyFirst,
					shutdown_msg, announcement_sigs,
					commitment_update: None, raa: None,
					commitment_order: self.context.resend_order.clone(),
					tx_signatures: tx_signatures
						.map(|msg| (TxSignaturesOrder::SignaturesFirst, msg)),
					tx_abort,
					splice_locked,
					inferred_splice_locked,
				})
			} else {
				let commitment_update = if self.context.resend_order == RAACommitmentOrder::RevokeAndACKFirst
					&& self.context.signer_pending_revoke_and_ack {
					log_trace!(logger, "Reconnected channel with lost outbound RAA and lost remote commitment tx, but unable to send due to resend order, waiting on signer for revoke and ack");
					self.context.signer_pending_commitment_update = true;
					None
				} else {
					self.get_last_commitment_update_for_send(logger).ok()
				};
				let raa = if self.context.resend_order == RAACommitmentOrder::CommitmentFirst
					&& self.context.signer_pending_commitment_update && required_revoke.is_some() {
					log_trace!(logger, "Reconnected channel with lost outbound RAA and lost remote commitment tx, but unable to send due to resend order, waiting on signer for commitment update");
					self.context.signer_pending_revoke_and_ack = true;
					None
				} else {
					required_revoke
				};
				Ok(ReestablishResponses {
					channel_ready,
					channel_ready_order: ChannelReadyOrder::ChannelReadyFirst,
					shutdown_msg, announcement_sigs,
					raa, commitment_update,
					commitment_order: self.context.resend_order.clone(),
					tx_signatures: tx_signatures
						.map(|msg| (TxSignaturesOrder::SignaturesFirst, msg)),
					tx_abort,
					splice_locked,
					inferred_splice_locked,
				})
			}
		} else if msg.next_local_commitment_number < next_counterparty_commitment_number {
			Err(ChannelError::close(format!(
				"Peer attempted to reestablish channel with a very old remote commitment transaction: {} (received) vs {} (expected)",
				msg.next_local_commitment_number,
				next_counterparty_commitment_number,
			)))
		} else {
			Err(ChannelError::close(format!(
				"Peer attempted to reestablish channel with a future remote commitment transaction: {} (received) vs {} (expected)",
				msg.next_local_commitment_number,
				next_counterparty_commitment_number,
			)))
		}
	}

	/// Calculates and returns our minimum and maximum closing transaction fee amounts, in whole
	/// satoshis. The amounts remain consistent unless a peer disconnects/reconnects or we restart,
	/// at which point they will be recalculated.
	fn calculate_closing_fee_limits<F: FeeEstimator>(
		&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> (u64, u64) {
		if let Some((min, max)) = self.context.closing_fee_limits {
			return (min, max);
		}

		// Propose a range from our current Background feerate to our Normal feerate plus our
		// force_close_avoidance_max_fee_satoshis.
		// If we fail to come to consensus, we'll have to force-close.
		let mut proposed_feerate =
			fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::ChannelCloseMinimum);
		// Use NonAnchorChannelFee because this should be an estimate for a channel close
		// that we don't expect to need fee bumping
		let normal_feerate =
			fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
		let mut proposed_max_feerate =
			if self.funding.is_outbound() { normal_feerate } else { u32::max_value() };

		// The spec requires that (when the channel does not have anchors) we only send absolute
		// channel fees no greater than the absolute channel fee on the current commitment
		// transaction. It's unclear *which* commitment transaction this refers to, and there isn't
		// very good reason to apply such a limit in any case. We don't bother doing so, risking
		// some force-closure by old nodes, but we wanted to close the channel anyway.

		if let Some(target_feerate) = self.context.target_closing_feerate_sats_per_kw {
			let min_feerate = if self.funding.is_outbound() {
				target_feerate
			} else {
				cmp::min(self.context.feerate_per_kw, target_feerate)
			};
			proposed_feerate = cmp::max(proposed_feerate, min_feerate);
			proposed_max_feerate = cmp::max(proposed_max_feerate, min_feerate);
		}

		// Note that technically we could end up with a lower minimum fee if one sides' balance is
		// below our dust limit, causing the output to disappear. We don't bother handling this
		// case, however, as this should only happen if a channel is closed before any (material)
		// payments have been made on it. This may cause slight fee overpayment and/or failure to
		// come to consensus with our counterparty on appropriate fees, however it should be a
		// relatively rare case. We can revisit this later, though note that in order to determine
		// if the funders' output is dust we have to know the absolute fee we're going to use.
		let tx_weight = self.get_closing_transaction_weight(
			Some(&self.get_closing_scriptpubkey()),
			Some(self.context.counterparty_shutdown_scriptpubkey.as_ref().unwrap()),
		);
		let proposed_total_fee_satoshis = proposed_feerate as u64 * tx_weight / 1000;
		let proposed_max_total_fee_satoshis = if self.funding.is_outbound() {
			// We always add force_close_avoidance_max_fee_satoshis to our normal
			// feerate-calculated fee, but allow the max to be overridden if we're using a
			// target feerate-calculated fee.
			cmp::max(
				normal_feerate as u64 * tx_weight / 1000
					+ self.context.config.options.force_close_avoidance_max_fee_satoshis,
				proposed_max_feerate as u64 * tx_weight / 1000,
			)
		} else {
			self.funding.get_value_satoshis() - self.funding.value_to_self_msat.div_ceil(1000)
		};

		self.context.closing_fee_limits =
			Some((proposed_total_fee_satoshis, proposed_max_total_fee_satoshis));
		self.context.closing_fee_limits.clone().unwrap()
	}

	/// Returns true if we're ready to commence the closing_signed negotiation phase. This is true
	/// after both sides have exchanged a `shutdown` message and all HTLCs have been drained. At
	/// this point if we're the funder we should send the initial closing_signed, and in any case
	/// shutdown should complete within a reasonable timeframe.
	fn closing_negotiation_ready(&self) -> bool {
		self.context.closing_negotiation_ready()
	}

	/// Checks if the closing_signed negotiation is making appropriate progress, possibly returning
	/// an Err if no progress is being made and the channel should be force-closed instead.
	/// Should be called on a one-minute timer.
	pub fn timer_check_closing_negotiation_progress(&mut self) -> Result<(), ChannelError> {
		if self.closing_negotiation_ready() {
			if self.context.closing_signed_in_flight {
				return Err(ChannelError::close(
					"closing_signed negotiation failed to finish within two timer ticks".to_owned(),
				));
			} else {
				self.context.closing_signed_in_flight = true;
			}
		}
		Ok(())
	}

	pub fn maybe_propose_closing_signed<F: FeeEstimator, L: Logger>(
		&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<(Option<msgs::ClosingSigned>, Option<(Transaction, ShutdownResult)>), ChannelError>
	{
		// If we're waiting on a monitor persistence, that implies we're also waiting to send some
		// message to our counterparty (probably a `revoke_and_ack`). In such a case, we shouldn't
		// initiate `closing_signed` negotiation until we're clear of all pending messages. Note
		// that closing_negotiation_ready checks this case (as well as a few others).
		if self.context.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
			return Ok((None, None));
		}

		if !self.funding.is_outbound() {
			if let Some(msg) = &self.context.pending_counterparty_closing_signed.take() {
				return self.closing_signed(fee_estimator, &msg, logger);
			}
			return Ok((None, None));
		}

		// If we're waiting on a counterparty `commitment_signed` to clear some updates from our
		// local commitment transaction, we can't yet initiate `closing_signed` negotiation.
		if self.context.expecting_peer_commitment_signed {
			return Ok((None, None));
		}

		let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);

		assert!(self.context.shutdown_scriptpubkey.is_some());
		let (closing_tx, total_fee_satoshis) =
			self.build_closing_transaction(our_min_fee, false)?;
		log_trace!(logger, "Proposing initial closing_signed for our counterparty with a fee range of {}-{} sat (with initial proposal {} sats)",
			our_min_fee, our_max_fee, total_fee_satoshis);

		let closing_signed = self.get_closing_signed_msg(
			&closing_tx,
			false,
			total_fee_satoshis,
			our_min_fee,
			our_max_fee,
			logger,
		);
		Ok((closing_signed, None))
	}

	fn mark_response_received(&mut self) {
		self.context.sent_message_awaiting_response = None;
	}

	/// Determines whether we should disconnect the counterparty due to not receiving a response
	/// within our expected timeframe.
	///
	/// This should be called for peers with an active socket on every
	/// [`super::channelmanager::ChannelManager::timer_tick_occurred`].
	#[allow(clippy::assertions_on_constants)]
	#[rustfmt::skip]
	pub fn should_disconnect_peer_awaiting_response(&mut self) -> bool {
		if let Some(ticks_elapsed) = self.context.sent_message_awaiting_response.as_mut() {
			*ticks_elapsed += 1;
			*ticks_elapsed >= DISCONNECT_PEER_AWAITING_RESPONSE_TICKS
		} else if
			// Cleared upon receiving `channel_reestablish`.
			self.context.channel_state.is_peer_disconnected()
			// Cleared upon receiving `stfu`.
			|| self.context.channel_state.is_local_stfu_sent()
			// Cleared upon receiving a message that triggers the end of quiescence.
			|| self.context.channel_state.is_quiescent()
			// Cleared upon receiving `revoke_and_ack`. Since we're not queiscent, as we just
			// checked above, we intentionally don't disconnect our counterparty if we're waiting on
			// a monitor update or signer request.
			|| (self.context.is_waiting_on_peer_pending_channel_update()
				&& !self.context.is_monitor_or_signer_pending_channel_update())
		{
			// This is the first tick we've seen after expecting to make forward progress.
			self.context.sent_message_awaiting_response = Some(1);
			debug_assert!(DISCONNECT_PEER_AWAITING_RESPONSE_TICKS > 1);
			false
		} else {
			// Don't disconnect when we're not waiting on a response.
			false
		}
	}

	pub fn shutdown<L: Logger>(
		&mut self, logger: &L, signer_provider: &SP, their_features: &InitFeatures,
		msg: &msgs::Shutdown,
	) -> (
		Result<
			(Option<msgs::Shutdown>, Option<ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>),
			ChannelError,
		>,
		Option<SpliceFundingFailed>,
	) {
		if self.context.channel_state.is_peer_disconnected() {
			return (
				Err(ChannelError::close(
					"Peer sent shutdown when we needed a channel_reestablish".to_owned(),
				)),
				None,
			);
		}
		let mut not_broadcasted_initial_funding =
			matches!(self.context.channel_state, ChannelState::NegotiatingFunding(_));
		if matches!(self.context.channel_state, ChannelState::FundingNegotiated(_)) {
			if let Some(signing_session) = self.context.interactive_tx_signing_session.as_ref() {
				if !signing_session.has_holder_witnesses() {
					// If we're a V1 channel or we haven't yet sent our `tx_signatures` for a dual
					// funded channel, the funding tx couldn't be broadcasted yet, so just short-circuit
					// the shutdown logic.
					not_broadcasted_initial_funding = true;
				}
			}
		}
		if not_broadcasted_initial_funding {
			// Spec says we should fail the connection, not the channel, but that's nonsense, there
			// are plenty of reasons you may want to fail a channel pre-funding, and spec says you
			// can do that via error message without getting a connection fail anyway...
			return (
				Err(ChannelError::close("Shutdown before funding was broadcasted".to_owned())),
				None,
			);
		}
		for htlc in self.context.pending_inbound_htlcs.iter() {
			if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
				return (
					Err(ChannelError::close("Got shutdown with remote pending HTLCs".to_owned())),
					None,
				);
			}
		}
		assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));

		if self.context.channel_state.is_local_stfu_sent()
			|| self.context.channel_state.is_remote_stfu_sent()
			|| self.context.channel_state.is_quiescent()
		{
			let splice_funding_failed = self.abandon_quiescent_action();
			return (
				Err(ChannelError::WarnAndDisconnect(
					"Got shutdown request while quiescent".to_owned(),
				)),
				splice_funding_failed,
			);
		}

		if !script::is_bolt2_compliant(&msg.scriptpubkey, their_features) {
			return (
				Err(ChannelError::Warn(format!(
					"Got a nonstandard scriptpubkey ({}) from remote peer",
					msg.scriptpubkey.to_hex_string()
				))),
				None,
			);
		}

		if self.context.counterparty_shutdown_scriptpubkey.is_some() {
			if Some(&msg.scriptpubkey) != self.context.counterparty_shutdown_scriptpubkey.as_ref() {
				return (Err(ChannelError::Warn(format!("Got shutdown request with a scriptpubkey ({}) which did not match their previous scriptpubkey.", msg.scriptpubkey.to_hex_string()))), None);
			}
		} else {
			self.context.counterparty_shutdown_scriptpubkey = Some(msg.scriptpubkey.clone());
		}

		// If we have any LocalAnnounced updates we'll probably just get back an update_fail_htlc
		// immediately after the commitment dance, but we can send a Shutdown because we won't send
		// any further commitment updates after we set LocalShutdownSent.
		let send_shutdown = !self.context.channel_state.is_local_shutdown_sent();

		let update_shutdown_script = match self.context.shutdown_scriptpubkey {
			Some(_) => false,
			None => {
				assert!(send_shutdown);
				let shutdown_scriptpubkey = match signer_provider.get_shutdown_scriptpubkey() {
					Ok(scriptpubkey) => scriptpubkey,
					Err(_) => {
						return (
							Err(ChannelError::close(
								"Failed to get shutdown scriptpubkey".to_owned(),
							)),
							None,
						)
					},
				};
				if !shutdown_scriptpubkey.is_compatible(their_features) {
					return (
						Err(ChannelError::close(format!(
							"Provided a scriptpubkey format not accepted by peer: {}",
							shutdown_scriptpubkey
						))),
						None,
					);
				}
				self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
				true
			},
		};

		// From here on out, we may not fail!

		self.context.channel_state.set_remote_shutdown_sent();
		self.context.update_time_counter += 1;

		let monitor_update = if update_shutdown_script {
			self.context.latest_monitor_update_id += 1;
			let monitor_update = ChannelMonitorUpdate {
				update_id: self.context.latest_monitor_update_id,
				updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
					scriptpubkey: self.get_closing_scriptpubkey(),
				}],
				channel_id: Some(self.context.channel_id()),
			};
			self.monitor_updating_paused(
				false,
				false,
				false,
				Vec::new(),
				Vec::new(),
				Vec::new(),
				logger,
			);
			self.push_ret_blockable_mon_update(monitor_update)
		} else {
			None
		};
		let shutdown = if send_shutdown {
			Some(msgs::Shutdown {
				channel_id: self.context.channel_id,
				scriptpubkey: self.get_closing_scriptpubkey(),
			})
		} else {
			None
		};

		// We can't send our shutdown until we've committed all of our pending HTLCs, but the
		// remote side is unlikely to accept any new HTLCs, so we go ahead and "free" any holding
		// cell HTLCs and return them to fail the payment.
		self.context.holding_cell_update_fee = None;
		let mut dropped_outbound_htlcs =
			Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
		self.context.holding_cell_htlc_updates.retain(|htlc_update| match htlc_update {
			&HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
				dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
				false
			},
			_ => true,
		});

		self.context.channel_state.set_local_shutdown_sent();
		self.context.update_time_counter += 1;

		let splice_funding_failed = self.abandon_quiescent_action();

		(Ok((shutdown, monitor_update, dropped_outbound_htlcs)), splice_funding_failed)
	}

	fn build_signed_closing_transaction(
		&self, closing_tx: &ClosingTransaction, counterparty_sig: &Signature, sig: &Signature,
	) -> Transaction {
		let mut tx = closing_tx.trust().built_transaction().clone();

		tx.input[0].witness.push(Vec::new()); // First is the multisig dummy

		let funding_key = self.funding.get_holder_pubkeys().funding_pubkey.serialize();
		let counterparty_funding_key = self.funding.counterparty_funding_pubkey().serialize();
		let mut holder_sig = sig.serialize_der().to_vec();
		holder_sig.push(EcdsaSighashType::All as u8);
		let mut cp_sig = counterparty_sig.serialize_der().to_vec();
		cp_sig.push(EcdsaSighashType::All as u8);
		if funding_key[..] < counterparty_funding_key[..] {
			tx.input[0].witness.push(holder_sig);
			tx.input[0].witness.push(cp_sig);
		} else {
			tx.input[0].witness.push(cp_sig);
			tx.input[0].witness.push(holder_sig);
		}

		tx.input[0].witness.push(self.funding.get_funding_redeemscript().into_bytes());
		tx
	}

	fn get_closing_signed_msg<L: Logger>(
		&mut self, closing_tx: &ClosingTransaction, skip_remote_output: bool, fee_satoshis: u64,
		min_fee_satoshis: u64, max_fee_satoshis: u64, logger: &L,
	) -> Option<msgs::ClosingSigned> {
		let sig = self
			.context
			.holder_signer
			.sign_closing_transaction(
				&self.funding.channel_transaction_parameters,
				closing_tx,
				&self.context.secp_ctx,
			)
			.ok();
		if sig.is_none() {
			log_trace!(logger, "Closing transaction signature unavailable, waiting on signer");
			self.context.signer_pending_closing = true;
		} else {
			self.context.signer_pending_closing = false;
		}
		let fee_range = msgs::ClosingSignedFeeRange { min_fee_satoshis, max_fee_satoshis };
		self.context.last_sent_closing_fee =
			Some((fee_satoshis, skip_remote_output, fee_range.clone(), sig.clone()));
		sig.map(|signature| msgs::ClosingSigned {
			channel_id: self.context.channel_id,
			fee_satoshis,
			signature,
			fee_range: Some(fee_range),
		})
	}

	fn shutdown_result_coop_close(&self) -> ShutdownResult {
		let closure_reason = if self.initiated_shutdown() {
			ClosureReason::LocallyInitiatedCooperativeClosure
		} else {
			ClosureReason::CounterpartyInitiatedCooperativeClosure
		};
		ShutdownResult {
			closure_reason,
			monitor_update: None,
			dropped_outbound_htlcs: Vec::new(),
			unbroadcasted_batch_funding_txid: self
				.context
				.unbroadcasted_batch_funding_txid(&self.funding),
			channel_id: self.context.channel_id,
			user_channel_id: self.context.user_id,
			channel_capacity_satoshis: self.funding.get_value_satoshis(),
			counterparty_node_id: self.context.counterparty_node_id,
			unbroadcasted_funding_tx: self.context.unbroadcasted_funding(&self.funding),
			is_manual_broadcast: self.context.is_manual_broadcast,
			channel_funding_txo: self.funding.get_funding_txo(),
			last_local_balance_msat: self.funding.value_to_self_msat,
			splice_funding_failed: Vec::new(),
			splice_funding_negotiated: None,
		}
	}

	pub fn closing_signed<F: FeeEstimator, L: Logger>(
		&mut self, fee_estimator: &LowerBoundedFeeEstimator<F>, msg: &msgs::ClosingSigned,
		logger: &L,
	) -> Result<(Option<msgs::ClosingSigned>, Option<(Transaction, ShutdownResult)>), ChannelError>
	{
		if self.is_shutdown_pending_signature() {
			return Err(ChannelError::Warn(String::from("Remote end sent us a closing_signed while fully shutdown and just waiting on the final closing signature")));
		}
		if !self.context.channel_state.is_both_sides_shutdown() {
			return Err(ChannelError::close(
				"Remote end sent us a closing_signed before both sides provided a shutdown"
					.to_owned(),
			));
		}
		if self.context.channel_state.is_peer_disconnected() {
			return Err(ChannelError::close(
				"Peer sent closing_signed when we needed a channel_reestablish".to_owned(),
			));
		}
		if !self.context.pending_inbound_htlcs.is_empty()
			|| !self.context.pending_outbound_htlcs.is_empty()
		{
			return Err(ChannelError::close(
				"Remote end sent us a closing_signed while there were still pending HTLCs"
					.to_owned(),
			));
		}
		if msg.fee_satoshis > TOTAL_BITCOIN_SUPPLY_SATOSHIS {
			// this is required to stop potential overflow in build_closing_transaction
			return Err(ChannelError::close(
				"Remote tried to send us a closing tx with > 21 million BTC fee".to_owned(),
			));
		}

		if self.funding.is_outbound() && self.context.last_sent_closing_fee.is_none() {
			return Err(ChannelError::close("Remote tried to send a closing_signed when we were supposed to propose the first one".to_owned()));
		}

		if self.context.channel_state.is_monitor_update_in_progress() {
			self.context.pending_counterparty_closing_signed = Some(msg.clone());
			return Ok((None, None));
		}

		let funding_redeemscript = self.funding.get_funding_redeemscript();
		let mut skip_remote_output = false;
		let (mut closing_tx, used_total_fee) =
			self.build_closing_transaction(msg.fee_satoshis, skip_remote_output)?;
		if used_total_fee != msg.fee_satoshis {
			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)));
		}
		let sighash = closing_tx
			.trust()
			.get_sighash_all(&funding_redeemscript, self.funding.get_value_satoshis());

		match self.context.secp_ctx.verify_ecdsa(
			&sighash,
			&msg.signature,
			&self.funding.get_counterparty_pubkeys().funding_pubkey,
		) {
			Ok(_) => {},
			Err(_e) => {
				// The remote end may have decided to revoke their output due to inconsistent dust
				// limits, so check for that case by re-checking the signature here.
				skip_remote_output = true;
				closing_tx =
					self.build_closing_transaction(msg.fee_satoshis, skip_remote_output)?.0;
				let sighash = closing_tx
					.trust()
					.get_sighash_all(&funding_redeemscript, self.funding.get_value_satoshis());
				let res = self.context.secp_ctx.verify_ecdsa(
					&sighash,
					&msg.signature,
					self.funding.counterparty_funding_pubkey(),
				);
				secp_check!(res, "Invalid closing tx signature from peer".to_owned());
			},
		};

		for outp in closing_tx.trust().built_transaction().output.iter() {
			if !outp.script_pubkey.is_witness_program()
				&& outp.value < Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS)
			{
				return Err(ChannelError::close("Remote sent us a closing_signed with a dust output. Always use segwit closing scripts!".to_owned()));
			}
		}

		assert!(self.context.shutdown_scriptpubkey.is_some());
		if let Some((last_fee, _, _, Some(sig))) = self.context.last_sent_closing_fee {
			if last_fee == msg.fee_satoshis {
				let shutdown_result = self.shutdown_result_coop_close();
				let tx =
					self.build_signed_closing_transaction(&mut closing_tx, &msg.signature, &sig);
				self.context.channel_state = ChannelState::ShutdownComplete;
				self.context.update_time_counter += 1;
				return Ok((None, Some((tx, shutdown_result))));
			}
		}

		let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);

		macro_rules! propose_fee {
			($new_fee: expr) => {
				let (closing_tx, used_fee) = if $new_fee == msg.fee_satoshis {
					(closing_tx, $new_fee)
				} else {
					skip_remote_output = false;
					self.build_closing_transaction($new_fee, skip_remote_output)?
				};

				let closing_signed = self.get_closing_signed_msg(
					&closing_tx,
					skip_remote_output,
					used_fee,
					our_min_fee,
					our_max_fee,
					logger,
				);
				let signed_tx_shutdown = if $new_fee == msg.fee_satoshis {
					self.context.update_time_counter += 1;
					self.context.last_received_closing_sig = Some(msg.signature.clone());
					if let Some(ClosingSigned { signature, .. }) = &closing_signed {
						let shutdown_result = self.shutdown_result_coop_close();
						self.context.channel_state = ChannelState::ShutdownComplete;
						let tx = self.build_signed_closing_transaction(
							&closing_tx,
							&msg.signature,
							signature,
						);
						Some((tx, shutdown_result))
					} else {
						None
					}
				} else {
					None
				};
				return Ok((closing_signed, signed_tx_shutdown))
			};
		}

		if let Some(msgs::ClosingSignedFeeRange { min_fee_satoshis, max_fee_satoshis }) =
			msg.fee_range
		{
			if msg.fee_satoshis < min_fee_satoshis || msg.fee_satoshis > max_fee_satoshis {
				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)));
			}
			if max_fee_satoshis < our_min_fee {
				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)));
			}
			if min_fee_satoshis > our_max_fee {
				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)));
			}

			if !self.funding.is_outbound() {
				// They have to pay, so pick the highest fee in the overlapping range.
				// We should never set an upper bound aside from their full balance
				debug_assert_eq!(
					our_max_fee,
					self.funding.get_value_satoshis()
						- self.funding.value_to_self_msat.div_ceil(1000)
				);
				propose_fee!(cmp::min(max_fee_satoshis, our_max_fee));
			} else {
				if msg.fee_satoshis < our_min_fee || msg.fee_satoshis > our_max_fee {
					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.",
						msg.fee_satoshis, our_min_fee, our_max_fee)));
				}
				// The proposed fee is in our acceptable range, accept it and broadcast!
				propose_fee!(msg.fee_satoshis);
			}
		} else {
			// Old fee style negotiation. We don't bother to enforce whether they are complying
			// with the "making progress" requirements, we just comply and hope for the best.
			if let Some((last_fee, _, _, _)) = self.context.last_sent_closing_fee {
				if msg.fee_satoshis > last_fee {
					if msg.fee_satoshis < our_max_fee {
						propose_fee!(msg.fee_satoshis);
					} else if last_fee < our_max_fee {
						propose_fee!(our_max_fee);
					} else {
						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)));
					}
				} else {
					if msg.fee_satoshis > our_min_fee {
						propose_fee!(msg.fee_satoshis);
					} else if last_fee > our_min_fee {
						propose_fee!(our_min_fee);
					} else {
						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)));
					}
				}
			} else {
				if msg.fee_satoshis < our_min_fee {
					propose_fee!(our_min_fee);
				} else if msg.fee_satoshis > our_max_fee {
					propose_fee!(our_max_fee);
				} else {
					propose_fee!(msg.fee_satoshis);
				}
			}
		}
	}

	#[rustfmt::skip]
	fn internal_htlc_satisfies_config(
		&self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32, config: &ChannelConfig,
	) -> Result<(), LocalHTLCFailureReason> {
		let fee = amt_to_forward.checked_mul(config.forwarding_fee_proportional_millionths as u64)
			.and_then(|prop_fee| (prop_fee / 1000000).checked_add(config.forwarding_fee_base_msat as u64));
		if fee.is_none() || htlc.amount_msat < fee.unwrap() ||
			(htlc.amount_msat - fee.unwrap()) < amt_to_forward {
			return Err(LocalHTLCFailureReason::FeeInsufficient);
		}
		if (htlc.cltv_expiry as u64) < outgoing_cltv_value as u64 + config.cltv_expiry_delta as u64 {
			return Err(LocalHTLCFailureReason::IncorrectCLTVExpiry);
		}
		Ok(())
	}

	/// Determines whether the parameters of an incoming HTLC to be forwarded satisfy the channel's
	/// [`ChannelConfig`]. This first looks at the channel's current [`ChannelConfig`], and if
	/// unsuccessful, falls back to the previous one if one exists.
	pub fn htlc_satisfies_config(
		&self, htlc: &msgs::UpdateAddHTLC, amt_to_forward: u64, outgoing_cltv_value: u32,
	) -> Result<(), LocalHTLCFailureReason> {
		self.internal_htlc_satisfies_config(
			&htlc,
			amt_to_forward,
			outgoing_cltv_value,
			&self.context.config(),
		)
		.or_else(|err| {
			if let Some(prev_config) = self.context.prev_config() {
				self.internal_htlc_satisfies_config(
					htlc,
					amt_to_forward,
					outgoing_cltv_value,
					&prev_config,
				)
			} else {
				Err(err)
			}
		})
	}

	/// When this function is called, the HTLC is already irrevocably committed to the channel;
	/// this function determines whether to fail the HTLC, or forward / claim it.
	#[rustfmt::skip]
	pub fn can_accept_incoming_htlc<F: FeeEstimator, L: Logger>(
		&self, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: L
	) -> Result<(), LocalHTLCFailureReason> {
		if self.context.channel_state.is_local_shutdown_sent() {
			return Err(LocalHTLCFailureReason::ChannelClosed)
		}

		let dust_exposure_limiting_feerate = self.context.get_dust_exposure_limiting_feerate(
			&fee_estimator, self.funding.get_channel_type(),
		);

		core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.try_for_each(|funding| self.context.can_accept_incoming_htlc(funding, dust_exposure_limiting_feerate, &logger))
	}

	pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
		self.holder_commitment_point.current_transaction_number()
	}

	pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
		self.context.counterparty_next_commitment_transaction_number + 1
			- if self.context.channel_state.is_awaiting_remote_revoke() { 1 } else { 0 }
	}

	pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
		let ret = self.context.counterparty_next_commitment_transaction_number + 2;
		debug_assert_eq!(self.context.commitment_secrets.get_min_seen_secret(), ret);
		ret
	}

	#[cfg(any(test, feature = "_externalize_tests"))]
	pub fn get_signer(&self) -> &SP::EcdsaSigner {
		&self.context.holder_signer
	}

	#[cfg(any(test, feature = "_externalize_tests"))]
	#[rustfmt::skip]
	pub fn get_value_stat(&self) -> ChannelValueStat {
		ChannelValueStat {
			value_to_self_msat: self.funding.value_to_self_msat,
			channel_value_msat: self.funding.get_value_satoshis() * 1000,
			channel_reserve_msat: self.funding.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000,
			pending_outbound_htlcs_amount_msat: self.context.pending_outbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
			pending_inbound_htlcs_amount_msat: self.context.pending_inbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
			holding_cell_outbound_amount_msat: {
				let mut res = 0;
				for h in self.context.holding_cell_htlc_updates.iter() {
					match h {
						&HTLCUpdateAwaitingACK::AddHTLC{amount_msat, .. } => {
							res += amount_msat;
						}
						_ => {}
					}
				}
				res
			},
			counterparty_max_htlc_value_in_flight_msat: self.context.counterparty_max_htlc_value_in_flight_msat,
			counterparty_dust_limit_msat: self.context.counterparty_dust_limit_satoshis * 1000,
		}
	}

	/// Returns true if this channel has been marked as awaiting a monitor update to move forward.
	/// Allowed in any state (including after shutdown)
	pub fn is_awaiting_monitor_update(&self) -> bool {
		self.context.channel_state.is_monitor_update_in_progress()
	}

	/// Gets the latest [`ChannelMonitorUpdate`] ID which has been released and is in-flight.
	pub fn get_latest_unblocked_monitor_update_id(&self) -> u64 {
		self.context.get_latest_unblocked_monitor_update_id()
	}

	/// Returns the next blocked monitor update, if one exists, and a bool which indicates a
	/// further blocked monitor update exists after the next.
	pub fn unblock_next_blocked_monitor_update(&mut self) -> Option<(ChannelMonitorUpdate, bool)> {
		if self.context.blocked_monitor_updates.is_empty() {
			return None;
		}
		Some((
			self.context.blocked_monitor_updates.remove(0).update,
			!self.context.blocked_monitor_updates.is_empty(),
		))
	}

	/// Pushes a new monitor update into our monitor update queue, returning it if it should be
	/// immediately given to the user for persisting or `None` if it should be held as blocked.
	#[rustfmt::skip]
	fn push_ret_blockable_mon_update(&mut self, update: ChannelMonitorUpdate)
	-> Option<ChannelMonitorUpdate> {
		let release_monitor = self.context.blocked_monitor_updates.is_empty();
		if !release_monitor {
			self.context.blocked_monitor_updates.push(PendingChannelMonitorUpdate {
				update,
			});
			None
		} else {
			Some(update)
		}
	}

	/// On startup, its possible we detect some monitor updates have actually completed (and the
	/// ChannelManager was simply stale). In that case, we should simply drop them, which we do
	/// here after logging them.
	pub fn on_startup_drop_completed_blocked_mon_updates_through<L: Logger>(
		&mut self, logger: &L, loaded_mon_update_id: u64,
	) {
		self.context.blocked_monitor_updates.retain(|update| {
			if update.update.update_id <= loaded_mon_update_id {
				log_info!(
					logger,
					"Dropping completed ChannelMonitorUpdate id {} due to a stale ChannelManager",
					update.update.update_id,
				);
				false
			} else {
				true
			}
		});
	}

	pub fn blocked_monitor_updates_pending(&self) -> usize {
		self.context.blocked_monitor_updates.len()
	}

	/// Returns true if the channel is awaiting the persistence of the initial ChannelMonitor.
	/// If the channel is outbound, this implies we have not yet broadcasted the funding
	/// transaction. If the channel is inbound, this implies simply that the channel has not
	/// advanced state.
	#[rustfmt::skip]
	pub fn is_awaiting_initial_mon_persist(&self) -> bool {
		if !self.is_awaiting_monitor_update() { return false; }
		if matches!(
			self.context.channel_state, ChannelState::AwaitingChannelReady(flags)
			if flags.clone().clear(AwaitingChannelReadyFlags::THEIR_CHANNEL_READY | FundedStateFlags::PEER_DISCONNECTED | FundedStateFlags::MONITOR_UPDATE_IN_PROGRESS | AwaitingChannelReadyFlags::WAITING_FOR_BATCH).is_empty()
		) {
			// If we're not a 0conf channel, we'll be waiting on a monitor update with only
			// AwaitingChannelReady set, though our peer could have sent their channel_ready.
			debug_assert!(self.context.minimum_depth.unwrap_or(1) > 0);
			return true;
		}
		if self.holder_commitment_point.next_transaction_number() == INITIAL_COMMITMENT_NUMBER - 1 &&
			self.context.counterparty_next_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
			// If we're a 0-conf channel, we'll move beyond AwaitingChannelReady immediately even while
			// waiting for the initial monitor persistence. Thus, we check if our commitment
			// transaction numbers have both been iterated only exactly once (for the
			// funding_signed), and we're awaiting monitor update.
			//
			// If we got here, we shouldn't have yet broadcasted the funding transaction (as the
			// only way to get an awaiting-monitor-update state during initial funding is if the
			// initial monitor persistence is still pending).
			//
			// Because deciding we're awaiting initial broadcast spuriously could result in
			// funds-loss (as we don't have a monitor, but have the funding transaction confirmed),
			// we hard-assert here, even in production builds.
			if self.funding.is_outbound() { assert!(self.funding.funding_transaction.is_some()); }
			assert!(self.context.monitor_pending_channel_ready);
			assert_eq!(self.context.latest_monitor_update_id, 0);
			return true;
		}
		false
	}

	/// Gets the latest inbound SCID alias from our peer, or if none exists, the channel's real
	/// SCID.
	pub fn get_inbound_scid(&self) -> Option<u64> {
		self.context.latest_inbound_scid_alias.or(self.funding.get_short_channel_id())
	}

	/// Returns true if our channel_ready has been sent
	pub fn is_our_channel_ready(&self) -> bool {
		matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(flags) if flags.is_set(AwaitingChannelReadyFlags::OUR_CHANNEL_READY))
			|| matches!(self.context.channel_state, ChannelState::ChannelReady(_))
	}

	/// Returns true if our peer has either initiated or agreed to shut down the channel.
	pub fn received_shutdown(&self) -> bool {
		self.context.channel_state.is_remote_shutdown_sent()
	}

	/// Returns true if we either initiated or agreed to shut down the channel.
	pub fn sent_shutdown(&self) -> bool {
		self.context.channel_state.is_local_shutdown_sent()
	}

	/// Returns true if we initiated to shut down the channel.
	pub fn initiated_shutdown(&self) -> bool {
		self.context.local_initiated_shutdown.is_some()
	}

	/// Returns true if this channel is fully shut down. True here implies that no further actions
	/// may/will be taken on this channel, and thus this object should be freed. Any future changes
	/// will be handled appropriately by the chain monitor.
	pub fn is_shutdown(&self) -> bool {
		matches!(self.context.channel_state, ChannelState::ShutdownComplete)
	}

	pub fn is_shutdown_pending_signature(&self) -> bool {
		matches!(self.context.channel_state, ChannelState::ChannelReady(_))
			&& self.context.signer_pending_closing
			&& self.context.last_received_closing_sig.is_some()
	}

	pub fn channel_update_status(&self) -> ChannelUpdateStatus {
		self.context.channel_update_status
	}

	pub fn set_channel_update_status(&mut self, status: ChannelUpdateStatus) {
		self.context.update_time_counter += 1;
		self.context.channel_update_status = status;
	}

	#[rustfmt::skip]
	fn check_get_channel_ready<L: Logger>(&mut self, height: u32, logger: &L) -> Option<msgs::ChannelReady> {
		// Called:
		//  * always when a new block/transactions are confirmed with the new height
		//  * when funding is signed with a height of 0
		if !self.check_funding_meets_minimum_depth(&self.funding, height) {
			return None;
		}

		// Note that we don't include ChannelState::WaitingForBatch as we don't want to send
		// channel_ready until the entire batch is ready.
		let need_commitment_update = if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()).is_empty()) {
			self.context.channel_state.set_our_channel_ready();
			true
		} else if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()) == AwaitingChannelReadyFlags::THEIR_CHANNEL_READY) {
			self.context.channel_state = ChannelState::ChannelReady(self.context.channel_state.with_funded_state_flags_mask().into());
			self.context.update_time_counter += 1;
			true
		} else if matches!(self.context.channel_state, ChannelState::AwaitingChannelReady(f) if f.clone().clear(FundedStateFlags::ALL.into()) == AwaitingChannelReadyFlags::OUR_CHANNEL_READY) {
			// We got a reorg but not enough to trigger a force close, just ignore.
			false
		} else {
			if self.funding.funding_tx_confirmation_height != 0 &&
				self.context.channel_state < ChannelState::ChannelReady(ChannelReadyFlags::new())
			{
				// We should never see a funding transaction on-chain until we've received
				// funding_signed (if we're an outbound channel), or seen funding_generated (if we're
				// an inbound channel - before that we have no known funding TXID). The fuzzer,
				// however, may do this and we shouldn't treat it as a bug.
				#[cfg(not(fuzzing))]
				panic!("Started confirming a channel in a state pre-AwaitingChannelReady: {}.\n\
					Do NOT broadcast a funding transaction manually - let LDK do it for you!",
					self.context.channel_state.to_u32());
			}
			// We got a reorg but not enough to trigger a force close, just ignore.
			false
		};

		if !need_commitment_update {
			log_debug!(logger, "Not producing channel_ready: we do not need a commitment update");
			return None;
		}

		if self.context.channel_state.is_monitor_update_in_progress() {
			log_debug!(logger, "Not producing channel_ready: a monitor update is in progress. Setting monitor_pending_channel_ready.");
			self.context.monitor_pending_channel_ready = true;
			return None;
		}

		if self.context.channel_state.is_peer_disconnected() {
			log_debug!(logger, "Not producing channel_ready: the peer is disconnected.");
			return None;
		}

		self.get_channel_ready(logger)
	}

	#[rustfmt::skip]
	fn get_channel_ready<L: Logger>(
		&mut self, logger: &L
	) -> Option<msgs::ChannelReady> {
		if self.holder_commitment_point.can_advance() {
			self.context.signer_pending_channel_ready = false;
			Some(msgs::ChannelReady {
				channel_id: self.context.channel_id(),
				next_per_commitment_point: self.holder_commitment_point.next_point(),
				short_channel_id_alias: Some(self.context.outbound_scid_alias),
			})
		} else {
			log_debug!(logger, "Not producing channel_ready: the holder commitment point is not available.");
			self.context.signer_pending_channel_ready = true;
			None
		}
	}

	fn check_funding_meets_minimum_depth(&self, funding: &FundingScope, height: u32) -> bool {
		self.context.check_funding_meets_minimum_depth(funding, height)
	}

	/// Returns `Some` if a splice [`FundingScope`] was promoted.
	fn maybe_promote_splice_funding<NS: NodeSigner, L: Logger>(
		&mut self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
		block_height: u32, logger: &L,
	) -> Option<SpliceFundingPromotion> {
		let pending_splice = self.pending_splice.as_mut()?;
		let splice_txid = pending_splice.sent_funding_txid?;
		if let Some(received_funding_txid) = pending_splice.received_funding_txid {
			if splice_txid != received_funding_txid {
				log_warn!(
					logger,
					"Mismatched splice_locked txid for channel {}; sent txid {}; received txid {}",
					&self.context.channel_id,
					splice_txid,
					received_funding_txid,
				);
				return None;
			}
		} else {
			log_info!(logger, "Waiting on splice_locked txid {}", splice_txid);
			return None;
		}

		log_info!(logger, "Promoting splice funding txid {}", splice_txid);

		let (queued_splice_failed, earlier_contributions, later_contributions) = {
			let promoted_candidate_idx = pending_splice
				.negotiated_candidates
				.iter()
				.position(|candidate| candidate.funding.get_funding_txid() == Some(splice_txid))
				.unwrap();

			let promoted_tx = pending_splice.negotiated_candidates[promoted_candidate_idx]
				.funding
				.funding_transaction
				.as_ref()
				.expect("Promoted splice funding should have a funding transaction");

			let is_queued_contribution_conflicting = match self.quiescent_action.as_ref() {
				Some(QuiescentAction::Splice { contribution, .. }) => {
					contribution.contributed_inputs().any(|input| {
						promoted_tx.input.iter().any(|promoted| input == promoted.previous_output)
					}) || contribution.contributed_outputs().any(|output| {
						promoted_tx
							.output
							.iter()
							.any(|promoted| output == promoted.script_pubkey.as_script())
					})
				},
				_ => false,
			};
			let queued_splice_failed = if is_queued_contribution_conflicting {
				#[allow(irrefutable_let_patterns)]
				let QuiescentAction::Splice { contribution, .. } = self
					.quiescent_action
					.take()
					.expect("We just checked a conflicting queued contribution exists above")
				else {
					unreachable!()
				};
				// Like any failure, this releases what the contribution reserved for itself. Its
				// record covers what it inherited, so anything else it shares with the promoted
				// transaction was added back and is released, as it is for a round negotiated after
				// the promoted one.
				Some(SpliceFundingFailed::from_contribution(contribution))
			} else {
				// The promoted transaction uses nothing a queued contribution holds, and every
				// round it could have inherited from is being replaced, so it now owns all of its
				// reservations: a later failure must release all of them.
				if let Some(QuiescentAction::Splice { contribution, .. }) =
					self.quiescent_action.as_mut()
				{
					contribution.clear_pending_components();
				}
				None
			};

			if let Some(scid) = self.funding.short_channel_id {
				self.context.historical_scids.push(scid);
			}
			// Rounds negotiated before the promoted one may have lent it the inputs and outputs
			// it uses, while rounds negotiated after it can only have inherited them from it.
			// Keep the two apart, as they release their parts differently below.
			let mut candidates =
				core::mem::take(&mut pending_splice.negotiated_candidates).into_iter();
			let earlier_contributions: Vec<FundingContribution> = candidates
				.by_ref()
				.take(promoted_candidate_idx)
				.filter_map(|candidate| candidate.contribution)
				.collect();
			let mut promoted_candidate =
				candidates.next().expect("promoted_candidate_idx indexes the candidates");
			let later_contributions: Vec<FundingContribution> =
				candidates.filter_map(|candidate| candidate.contribution).collect();
			core::mem::swap(&mut self.funding, &mut promoted_candidate.funding);

			(queued_splice_failed, earlier_contributions, later_contributions)
		};

		let discarded_funding = {
			let promoted_tx = self
				.funding
				.funding_transaction
				.as_ref()
				.expect("Promoted splice funding should have a funding transaction");
			let queued_contribution = match self.quiescent_action.as_ref() {
				Some(QuiescentAction::Splice { contribution, .. }) => Some(contribution),
				_ => None,
			};
			let queued_inputs = || {
				queued_contribution
					.into_iter()
					.flat_map(|contribution| contribution.contributed_inputs())
			};
			let queued_output_scripts = || {
				queued_contribution
					.into_iter()
					.flat_map(|contribution| contribution.contributed_outputs())
			};

			// Each dropped contribution releases only what it reserved itself: anything it
			// inherited is released by the round it inherited from, and anything a surviving
			// queued contribution reuses now belongs to it and is released only if it fails.
			//
			// A round negotiated before the promoted one also withholds what the promoted
			// transaction uses, as the promoted round may have inherited it from there. A round
			// negotiated after it, like a negotiation still in progress, can only have inherited
			// such a part, which its record covers; anything else it shares with the promoted
			// transaction was added back, so it is released even though the promoted transaction
			// uses it.
			let earlier_released = earlier_contributions.into_iter().filter_map(|contribution| {
				contribution.into_unique_contributions(
					promoted_tx.input.iter().map(|i| i.previous_output).chain(queued_inputs()),
					promoted_tx
						.output
						.iter()
						.map(|o| o.script_pubkey.as_script())
						.chain(queued_output_scripts()),
				)
			});
			let pending_negotiation_contribution = pending_splice.negotiation_contribution.take();
			let later_released = later_contributions
				.into_iter()
				.chain(pending_negotiation_contribution)
				.filter_map(|contribution| {
					contribution.into_unique_contributions(queued_inputs(), queued_output_scripts())
				});
			earlier_released
				.chain(later_released)
				.map(|(inputs, outputs)| FundingInfo::Contribution {
					inputs,
					outputs: outputs.into_iter().map(|output| output.script_pubkey).collect(),
				})
				.collect::<Vec<_>>()
		};

		self.context.interactive_tx_signing_session = None;
		self.pending_splice = None;
		self.context.announcement_sigs = None;
		self.context.announcement_sigs_state = AnnouncementSigsState::NotSent;

		let funding_txo = self
			.funding
			.get_funding_txo()
			.expect("Splice FundingScope should always have a funding_txo");

		self.context.latest_monitor_update_id += 1;
		let monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![ChannelMonitorUpdateStep::RenegotiatedFundingLocked {
				funding_txid: funding_txo.txid,
			}],
			channel_id: Some(self.context.channel_id()),
		};
		self.monitor_updating_paused(
			false,
			false,
			false,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);
		let monitor_update = self.push_ret_blockable_mon_update(monitor_update);

		let announcement_sigs =
			self.get_announcement_sigs(node_signer, chain_hash, user_config, block_height, logger);

		Some(SpliceFundingPromotion {
			funding_txo,
			monitor_update,
			announcement_sigs,
			discarded_funding,
			splice_funding_failed: queued_splice_failed,
		})
	}

	/// Generates a pending `splice_locked` once any funding negotiation has completed, along with
	/// the resulting funding promotion if the counterparty's lock was already received.
	pub fn timer_check_splice_locked<NS: NodeSigner, L: Logger>(
		&mut self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
		best_block_height: u32, logger: &L,
	) -> Option<(msgs::SpliceLocked, Option<SpliceFundingPromotion>)> {
		// We intentionally check this early even though `check_get_splice_locked` already does to
		// prevent scanning splice candidates unnecessarily.
		if self.context.channel_state.is_quiescent() {
			return None;
		}

		let candidate_idx = {
			let pending_splice = self.pending_splice.as_ref()?;
			pending_splice.negotiated_candidates.iter().rposition(|candidate| {
				self.context
					.check_funding_meets_minimum_depth(&candidate.funding, best_block_height)
			})?
		};

		let splice_locked = self.pending_splice.as_mut()?.check_get_splice_locked(
			&self.context,
			candidate_idx,
			best_block_height,
		)?;
		log_info!(
			logger,
			"Sending splice_locked txid {} after completing funding negotiation",
			splice_locked.splice_txid,
		);

		let splice_promotion = self.maybe_promote_splice_funding(
			node_signer,
			chain_hash,
			user_config,
			best_block_height,
			logger,
		);
		Some((splice_locked, splice_promotion))
	}

	/// When a transaction is confirmed, we check whether it is or spends the funding transaction
	/// In the first case, we store the confirmation height and calculating the short channel id.
	/// In the second, we simply return an Err indicating we need to be force-closed now.
	#[rustfmt::skip]
	pub fn transactions_confirmed<NS: NodeSigner, L: Logger>(
		&mut self, block_hash: &BlockHash, tx_confirmation_height: u32, best_block_height: u32,
		txdata: &TransactionData,
		chain_hash: ChainHash, node_signer: &NS, user_config: &UserConfig, logger: &L
	) -> Result<(Option<FundingConfirmedMessage>, Vec<(HTLCSource, PaymentHash)>, Option<msgs::AnnouncementSignatures>, Option<SpliceRbfAbort>), ClosureReason> {
		// Confirmation callbacks may arrive behind our current best block. Use the later height so
		// exiting quiescence below cannot release an HTLC which is already too close to expiry.
		let timed_out_htlcs = self.remove_timed_out_holding_cell_htlcs(cmp::max(
			tx_confirmation_height,
			best_block_height,
		));
		let mut splice_rbf_abort = None;
		for &(index_in_block, tx) in txdata.iter() {
			let mut confirmed_tx = ConfirmedTransaction::from(tx);

			// If we allow 1-conf funding, we may need to check for channel_ready or splice_locked here
			// and send it immediately instead of waiting for a best_block_updated call (which may have
			// already happened for this block).
			let is_funding_tx_confirmed = self.context.check_for_funding_tx_confirmed(
				&mut self.funding, block_hash, tx_confirmation_height, index_in_block, &mut confirmed_tx, logger,
			)?;

			if is_funding_tx_confirmed {
				// If this is a coinbase transaction and not a 0-conf channel
				// we should update our min_depth to 100 to handle coinbase maturity
				if tx.is_coinbase() &&
					self.context.minimum_depth.unwrap_or(0) > 0 &&
					self.context.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
					self.funding.minimum_depth_override = Some(COINBASE_MATURITY);
				}

				if let Some(channel_ready) = self.check_get_channel_ready(tx_confirmation_height, logger) {
					log_info!(logger, "Sending a channel_ready to our peer");
					let announcement_sigs = self.get_announcement_sigs(node_signer, chain_hash, user_config, tx_confirmation_height, logger);
					return Ok((Some(FundingConfirmedMessage::Establishment(channel_ready)), timed_out_htlcs, announcement_sigs, splice_rbf_abort));
				}
			}

			let confirmed_funding_index = if let Some(pending_splice) = &mut self.pending_splice {
				let mut confirmed_funding_index = None;
				let mut funding_already_confirmed = false;

				let candidates =
					pending_splice.negotiated_candidates.iter_mut().map(|candidate| &mut candidate.funding);
				for (index, funding) in candidates.enumerate() {
					if self.context.check_for_funding_tx_confirmed(
						funding, block_hash, tx_confirmation_height, index_in_block, &mut confirmed_tx, logger,
					)? {
						if funding_already_confirmed || confirmed_funding_index.is_some() {
							let err_reason = "splice tx of another pending funding already confirmed";
							return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
						}

						confirmed_funding_index = Some(index);
					} else if funding.funding_tx_confirmation_height != 0 {
						funding_already_confirmed = true;
					}
				}

				confirmed_funding_index
			} else {
				None
			};

			if let Some(confirmed_funding_index) = confirmed_funding_index {
				splice_rbf_abort = self.abort_ongoing_rbf_after_splice_confirmation(logger);
				if let Some(pending_splice) = &mut self.pending_splice {
					if let Some(splice_locked) = pending_splice.check_get_splice_locked(
						&self.context,
						confirmed_funding_index,
						tx_confirmation_height,
					) {

						log_info!(
							logger,
							"Sending splice_locked txid {} to our peer for channel {}",
							splice_locked.splice_txid,
							&self.context.channel_id,
						);

						let (
							funding_txo,
							monitor_update,
							announcement_sigs,
							discarded_funding,
							splice_funding_failed,
						) =
							self.maybe_promote_splice_funding(
								node_signer, chain_hash, user_config, tx_confirmation_height, logger,
							).map(|splice_promotion| (
								Some(splice_promotion.funding_txo),
								splice_promotion.monitor_update,
								splice_promotion.announcement_sigs,
								splice_promotion.discarded_funding,
								splice_promotion.splice_funding_failed,
							)).unwrap_or((None, None, None, Vec::new(), None));

						return Ok((Some(FundingConfirmedMessage::Splice(
							splice_locked,
							funding_txo,
							monitor_update,
							discarded_funding,
							splice_funding_failed,
						)), timed_out_htlcs, announcement_sigs, splice_rbf_abort));
					}
				}
			}

		}

		Ok((None, timed_out_htlcs, None, splice_rbf_abort))
	}

	/// When a new block is connected, we check the height of the block against outbound holding
	/// cell HTLCs in case we need to give up on them prematurely and time them out. Everything
	/// else (e.g. commitment transaction broadcasts, HTLC transaction broadcasting, etc) is
	/// handled by the ChannelMonitor.
	///
	/// If we return Err, the channel may have been closed, at which point the standard
	/// requirements apply - no calls may be made except those explicitly stated to be allowed
	/// post-shutdown.
	///
	/// May return some HTLCs (and their payment_hash) which have timed out and should be failed
	/// back.
	pub fn best_block_updated<NS: NodeSigner, L: Logger>(
		&mut self, height: u32, highest_header_time: Option<u32>, chain_hash: ChainHash,
		node_signer: &NS, user_config: &UserConfig, logger: &L,
	) -> Result<BestBlockUpdatedRes, ClosureReason> {
		self.do_best_block_updated(
			height,
			highest_header_time,
			Some((chain_hash, node_signer, user_config)),
			logger,
		)
	}

	/// Removes outbound holding-cell HTLCs which are too close to expiry to safely send.
	fn remove_timed_out_holding_cell_htlcs(
		&mut self, height: u32,
	) -> Vec<(HTLCSource, PaymentHash)> {
		let mut timed_out_htlcs = Vec::new();
		// Refuse to send an HTLC when our counterparty should almost certainly just fail it for
		// expiring ~now.
		let unforwarded_htlc_cltv_limit = height + LATENCY_GRACE_PERIOD_BLOCKS;
		self.context.holding_cell_htlc_updates.retain(|htlc_update| match htlc_update {
			&HTLCUpdateAwaitingACK::AddHTLC {
				ref payment_hash,
				ref source,
				ref cltv_expiry,
				..
			} => {
				if *cltv_expiry <= unforwarded_htlc_cltv_limit {
					timed_out_htlcs.push((source.clone(), payment_hash.clone()));
					false
				} else {
					true
				}
			},
			_ => true,
		});
		timed_out_htlcs
	}

	#[rustfmt::skip]
	fn do_best_block_updated<NS: NodeSigner, L: Logger>(
		&mut self, height: u32, highest_header_time: Option<u32>,
		chain_node_signer: Option<(ChainHash, &NS, &UserConfig)>, logger: &L
	) -> Result<BestBlockUpdatedRes, ClosureReason> {
		let timed_out_htlcs = self.remove_timed_out_holding_cell_htlcs(height);

		if let Some(time) = highest_header_time {
			self.context.update_time_counter = cmp::max(self.context.update_time_counter, time);
		}

		// Check if the funding transaction was unconfirmed
		let original_scid = self.funding.short_channel_id;
		let was_confirmed = self.funding.funding_tx_confirmed_in.is_some();
		let funding_tx_confirmations = self.funding.get_funding_tx_confirmations(height);
		if funding_tx_confirmations == 0 {
			self.funding.funding_tx_confirmation_height = 0;
			self.funding.short_channel_id = None;
			self.funding.funding_tx_confirmed_in = None;
		}

		if let Some(channel_ready) = self.check_get_channel_ready(height, logger) {
			let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
				self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger)
			} else { None };
			log_info!(logger, "Sending a channel_ready to our peer");
			return Ok((Some(FundingConfirmedMessage::Establishment(channel_ready)), timed_out_htlcs, announcement_sigs, None));
		}

		if matches!(self.context.channel_state, ChannelState::ChannelReady(_)) ||
			self.context.channel_state.is_our_channel_ready() {

			// If we've sent channel_ready (or have both sent and received channel_ready), and
			// the funding transaction has become unconfirmed, we'll probably get a new SCID when
			// it re-confirms.
			//
			// Worse, if the funding has un-confirmed we could have accepted some HTLC(s) over it
			// and are now at risk of double-spend. While its possible, even likely, that this is
			// just a trivial reorg and we should wait to see the new block connected in the next
			// call, its also possible we've been double-spent. To avoid further loss of funds, we
			// need some kind of method to freeze the channel and avoid accepting further HTLCs,
			// but absent such a method, we just force-close.
			//
			// The one exception we make is for 0-conf channels, which we decided to trust anyway,
			// in which case we simply track the previous SCID as a `historical_scids` the same as
			// after a channel is spliced.
			if funding_tx_confirmations == 0 && was_confirmed {
				if let Some(scid) = original_scid {
					self.context.historical_scids.push(scid);
				} else {
					debug_assert!(false);
				}
				if self.context.minimum_depth(&self.funding).expect("set for a ready channel") > 0 {
					// Reset the original short_channel_id so that we'll generate a closure
					// `channel_update` broadcast event.
					self.funding.short_channel_id = original_scid;
					let err_reason = format!("Funding transaction was un-confirmed, originally locked at {} confs.",
						self.context.minimum_depth.unwrap());
					return Err(ClosureReason::ProcessingError { err: err_reason });
				}
			}
		} else if !self.funding.is_outbound() && self.funding.funding_tx_confirmed_in.is_none() &&
				height >= self.context.channel_creation_height + FUNDING_CONF_DEADLINE_BLOCKS {
			log_info!(logger, "Closing channel due to funding timeout");
			// If funding_tx_confirmed_in is unset, the channel must not be active
			assert!(self.context.channel_state <= ChannelState::ChannelReady(ChannelReadyFlags::new()));
			assert!(!self.context.channel_state.is_our_channel_ready());
			return Err(ClosureReason::FundingTimedOut);
		}

		if let Some(pending_splice) = &mut self.pending_splice {
			let mut confirmed_funding_index = None;

			let candidates = pending_splice.negotiated_candidates.iter().map(|candidate| &candidate.funding);
			for (index, funding) in candidates.enumerate() {
				if funding.funding_tx_confirmation_height != 0 {
					if confirmed_funding_index.is_some() {
						let err_reason = "splice tx of another pending funding already confirmed";
						return Err(ClosureReason::ProcessingError { err: err_reason.to_owned() });
					}

					confirmed_funding_index = Some(index);
				}
			}

			if let Some(confirmed_funding_index) = confirmed_funding_index {
				let funding =
					&mut pending_splice.negotiated_candidates[confirmed_funding_index].funding;

				// Check if the splice funding transaction was unconfirmed
				if funding.get_funding_tx_confirmations(height) == 0 {
					funding.funding_tx_confirmation_height = 0;
					if let Some(sent_funding_txid) = pending_splice.sent_funding_txid {
						if Some(sent_funding_txid) == funding.get_funding_txid() {
							log_warn!(
								logger,
								"Unconfirming sent splice_locked txid {} for channel {}",
								sent_funding_txid,
								&self.context.channel_id,
							);
							pending_splice.sent_funding_txid = None;
						}
					}
				}

				if let Some(splice_locked) = pending_splice.check_get_splice_locked(
					&self.context,
					confirmed_funding_index,
					height,
				) {
					log_info!(
						logger, "Sending splice_locked txid {} to our peer",
						splice_locked.splice_txid,

					);

					let (
						funding_txo,
						monitor_update,
						announcement_sigs,
						discarded_funding,
						splice_funding_failed,
					) = chain_node_signer
						.and_then(|(chain_hash, node_signer, user_config)| {
							// We can only promote on blocks connected, which is when we expect
							// `chain_node_signer` to be `Some`.
							self.maybe_promote_splice_funding(node_signer, chain_hash, user_config, height, logger)
						})
						.map(|splice_promotion| (
							Some(splice_promotion.funding_txo),
							splice_promotion.monitor_update,
							splice_promotion.announcement_sigs,
							splice_promotion.discarded_funding,
							splice_promotion.splice_funding_failed,
						))
						.unwrap_or((None, None, None, Vec::new(), None));

					return Ok((Some(FundingConfirmedMessage::Splice(
						splice_locked,
						funding_txo,
						monitor_update,
						discarded_funding,
						splice_funding_failed,
					)), timed_out_htlcs, announcement_sigs, None));
				}
			}
		}

		let announcement_sigs = if let Some((chain_hash, node_signer, user_config)) = chain_node_signer {
			self.get_announcement_sigs(node_signer, chain_hash, user_config, height, logger)
		} else { None };
		Ok((None, timed_out_htlcs, announcement_sigs, None))
	}

	pub fn get_relevant_txids(&self) -> impl Iterator<Item = (Txid, u32, Option<BlockHash>)> + '_ {
		core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.map(|funding| {
				(
					funding.get_funding_txid(),
					funding.get_funding_tx_confirmation_height(),
					funding.funding_tx_confirmed_in,
				)
			})
			.filter_map(|(txid_opt, height_opt, hash_opt)| {
				if let (Some(funding_txid), Some(conf_height), Some(block_hash)) =
					(txid_opt, height_opt, hash_opt)
				{
					Some((funding_txid, conf_height, Some(block_hash)))
				} else {
					None
				}
			})
	}

	/// Checks if any funding transaction is no longer confirmed in the main chain. This may
	/// force-close the channel, but may also indicate a harmless reorganization of a block or two
	/// before the channel has reached channel_ready or splice_locked, and we can just wait for more
	/// blocks.
	#[rustfmt::skip]
	pub fn transaction_unconfirmed<L: Logger>(
		&mut self, txid: &Txid, logger: &L,
	) -> Result<(), ClosureReason> {
		let unconfirmed_funding = self
			.funding_and_pending_funding_iter_mut()
			.find(|funding| funding.get_funding_txid() == Some(*txid));

		if let Some(funding) = unconfirmed_funding {
			if funding.funding_tx_confirmation_height != 0 {
				// We handle the funding disconnection by calling best_block_updated with a height one
				// below where our funding was connected, implying a reorg back to conf_height - 1.
				let reorg_height = funding.funding_tx_confirmation_height - 1;

				let signer_config = None::<(ChainHash, &&dyn NodeSigner, &UserConfig)>;
				match self.do_best_block_updated(reorg_height, None, signer_config, logger) {
					Ok((channel_ready, timed_out_htlcs, announcement_sigs, splice_rbf_abort)) => {
						assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
						assert!(timed_out_htlcs.is_empty(), "We can't have accepted HTLCs with a timeout before our funding confirmation?");
						assert!(announcement_sigs.is_none(), "We can't generate an announcement_sigs with 0 confirmations?");
						assert!(splice_rbf_abort.is_none(), "We can't abort an RBF while unconfirming funding?");
						Ok(())
					},
					Err(e) => Err(e),
				}
			} else {
				// We never learned about the funding confirmation anyway, just ignore
				Ok(())
			}
		} else {
			Ok(())
		}
	}

	// Methods to get unprompted messages to send to the remote end (or where we already returned
	// something in the handler for the message that prompted this message):

	/// Gets an UnsignedChannelAnnouncement for this channel. The channel must be publicly
	/// announceable and available for use (have exchanged [`ChannelReady`] messages in both
	/// directions). Should be used for both broadcasted announcements and in response to an
	/// AnnouncementSignatures message from the remote peer.
	///
	/// Will only fail if we're not in a state where channel_announcement may be sent (including
	/// closing).
	///
	/// This will only return ChannelError::Ignore upon failure.
	///
	/// [`ChannelReady`]: crate::ln::msgs::ChannelReady
	#[rustfmt::skip]
	fn get_channel_announcement<NS: NodeSigner>(
		&self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
	) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> {
		if !self.context.config.announce_for_forwarding {
			return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
		}
		if !self.context.is_usable() {
			return Err(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel is not currently usable".to_owned()));
		}

		let short_channel_id = self.funding.get_short_channel_id()
			.ok_or(ChannelError::Ignore("Cannot get a ChannelAnnouncement if the channel has not been confirmed yet".to_owned()))?;
		let node_id = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
			.map_err(|_| ChannelError::Ignore("Failed to retrieve own public key".to_owned()))?);
		let counterparty_node_id = NodeId::from_pubkey(&self.context.get_counterparty_node_id());
		let were_node_one = node_id.as_slice() < counterparty_node_id.as_slice();

		let msg = msgs::UnsignedChannelAnnouncement {
			features: channelmanager::provided_channel_features(&user_config),
			chain_hash,
			short_channel_id,
			node_id_1: if were_node_one { node_id } else { counterparty_node_id },
			node_id_2: if were_node_one { counterparty_node_id } else { node_id },
			bitcoin_key_1: NodeId::from_pubkey(if were_node_one { &self.funding.get_holder_pubkeys().funding_pubkey } else { self.funding.counterparty_funding_pubkey() }),
			bitcoin_key_2: NodeId::from_pubkey(if were_node_one { self.funding.counterparty_funding_pubkey() } else { &self.funding.get_holder_pubkeys().funding_pubkey }),
			excess_data: Vec::new(),
		};

		Ok(msg)
	}

	#[rustfmt::skip]
	fn get_announcement_sigs<NS: NodeSigner, L: Logger>(
		&mut self, node_signer: &NS, chain_hash: ChainHash, user_config: &UserConfig,
		best_block_height: u32, logger: &L
	) -> Option<msgs::AnnouncementSignatures> {
		if self.funding.funding_tx_confirmation_height == 0 || self.funding.funding_tx_confirmation_height + 5 > best_block_height {
			return None;
		}

		if !self.context.is_usable() {
			return None;
		}

		if self.context.channel_state.is_peer_disconnected() {
			log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
			return None;
		}

		if self.context.announcement_sigs_state != AnnouncementSigsState::NotSent {
			return None;
		}

		log_trace!(logger, "Creating an announcement_signatures message");
		let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
			Ok(a) => a,
			Err(e) => {
				log_trace!(logger, "{:?}", e);
				return None;
			}
		};
		let our_node_sig = match node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement)) {
			Err(_) => {
				log_error!(logger, "Failed to generate node signature for channel_announcement. Channel will not be announced!");
				return None;
			},
			Ok(v) => v
		};
		let our_bitcoin_sig = match self.context.holder_signer.sign_channel_announcement_with_funding_key(
			&self.funding.channel_transaction_parameters,
			&announcement,
			&self.context.secp_ctx,
		) {
			Err(_) => {
				log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
				return None;
			},
			Ok(v) => v
		};
		let short_channel_id = match self.funding.get_short_channel_id() {
			Some(scid) => scid,
			None => return None,
		};

		self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;

		Some(msgs::AnnouncementSignatures {
			channel_id: self.context.channel_id(),
			short_channel_id,
			node_signature: our_node_sig,
			bitcoin_signature: our_bitcoin_sig,
		})
	}

	/// Signs the given channel announcement, returning a ChannelError::Ignore if no keys are
	/// available.
	#[rustfmt::skip]
	fn sign_channel_announcement<NS: NodeSigner>(
		&self, node_signer: &NS, announcement: msgs::UnsignedChannelAnnouncement
	) -> Result<msgs::ChannelAnnouncement, ChannelError> {
		if let Some((their_node_sig, their_bitcoin_sig)) = self.context.announcement_sigs {
			let our_node_key = NodeId::from_pubkey(&node_signer.get_node_id(Recipient::Node)
				.map_err(|_| ChannelError::Ignore("Signer failed to retrieve own public key".to_owned()))?);
			let were_node_one = announcement.node_id_1 == our_node_key;

			let our_node_sig = node_signer.sign_gossip_message(msgs::UnsignedGossipMessage::ChannelAnnouncement(&announcement))
				.map_err(|_| ChannelError::Ignore("Failed to generate node signature for channel_announcement".to_owned()))?;
			let our_bitcoin_sig = self.context.holder_signer
				.sign_channel_announcement_with_funding_key(
					&self.funding.channel_transaction_parameters,
					&announcement,
					&self.context.secp_ctx,
				)
				.map_err(|_| ChannelError::Ignore("Signer rejected channel_announcement".to_owned()))?;
			Ok(msgs::ChannelAnnouncement {
				node_signature_1: if were_node_one { our_node_sig } else { their_node_sig },
				node_signature_2: if were_node_one { their_node_sig } else { our_node_sig },
				bitcoin_signature_1: if were_node_one { our_bitcoin_sig } else { their_bitcoin_sig },
				bitcoin_signature_2: if were_node_one { their_bitcoin_sig } else { our_bitcoin_sig },
				contents: announcement,
			})
		} else {
			Err(ChannelError::Ignore("Attempted to sign channel announcement before we'd received announcement_signatures".to_string()))
		}
	}

	/// Processes an incoming announcement_signatures message, providing a fully-signed
	/// channel_announcement message which we can broadcast and storing our counterparty's
	/// signatures for later reconstruction/rebroadcast of the channel_announcement.
	#[rustfmt::skip]
	pub fn announcement_signatures<NS: NodeSigner>(
		&mut self, node_signer: &NS, chain_hash: ChainHash, best_block_height: u32,
		msg: &msgs::AnnouncementSignatures, user_config: &UserConfig
	) -> Result<msgs::ChannelAnnouncement, ChannelError> {
		// Ignore sigs signed over a `short_channel_id` other than our current one (e.g. stale
		// pre-splice sigs arriving after our side has promoted). Verifying them against the
		// current `UnsignedChannelAnnouncement` would always fail the hash check, but per BOLT #7
		// that's not a protocol violation warranting a force-close.
		if Some(msg.short_channel_id) != self.funding.get_short_channel_id() {
			return Err(ChannelError::Ignore(format!(
				"Ignoring announcement_signatures for short_channel_id {} which does not match our current short_channel_id {:?}",
				msg.short_channel_id, self.funding.get_short_channel_id(),
			)));
		}

		let announcement = self.get_channel_announcement(node_signer, chain_hash, user_config)?;

		let msghash = hash_to_message!(&Sha256d::hash(&announcement.encode()[..])[..]);

		if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.context.get_counterparty_node_id()).is_err() {
			return Err(ChannelError::close(format!(
				"Bad announcement_signatures. Failed to verify node_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_node_key is {:?}",
				 &announcement, self.context.get_counterparty_node_id())));
		}
		if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.funding.counterparty_funding_pubkey()).is_err() {
			return Err(ChannelError::close(format!(
				"Bad announcement_signatures. Failed to verify bitcoin_signature. UnsignedChannelAnnouncement used for verification is {:?}. their_bitcoin_key is ({:?})",
				&announcement, self.funding.counterparty_funding_pubkey())));
		}

		self.context.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
		if self.funding.funding_tx_confirmation_height == 0 || self.funding.funding_tx_confirmation_height + 5 > best_block_height {
			return Err(ChannelError::Ignore(
				"Got announcement_signatures prior to the required six confirmations - we may not have received a block yet that our peer has".to_owned()));
		}

		self.sign_channel_announcement(node_signer, announcement)
	}

	/// Gets a signed channel_announcement for this channel, if we previously received an
	/// announcement_signatures from our counterparty.
	#[rustfmt::skip]
	pub fn get_signed_channel_announcement<NS: NodeSigner>(
		&self, node_signer: &NS, chain_hash: ChainHash, best_block_height: u32, user_config: &UserConfig
	) -> Option<msgs::ChannelAnnouncement> {
		if self.funding.funding_tx_confirmation_height == 0 || self.funding.funding_tx_confirmation_height + 5 > best_block_height {
			return None;
		}
		let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
			Ok(res) => res,
			Err(_) => return None,
		};
		self.sign_channel_announcement(node_signer, announcement).ok()
	}

	fn maybe_get_next_funding(&self) -> Option<msgs::NextFunding> {
		// The sending node:
		//   - if it has sent `commitment_signed` for an interactive transaction construction but
		//     it has not received `tx_signatures`:
		self.context
			.interactive_tx_signing_session
			.as_ref()
			.filter(|session| !session.has_received_tx_signatures())
			.map(|signing_session| {
				// - MUST include the `next_funding` TLV.
				// - MUST set `next_funding_txid` to the txid of that interactive transaction.
				let mut next_funding = msgs::NextFunding {
					txid: signing_session.unsigned_tx().compute_txid(),
					retransmit_flags: 0,
				};

				// - if it has not received `commitment_signed` for this `next_funding_txid`:
				//   - MUST set the `commitment_signed` bit in `retransmit_flags`.
				if !signing_session.has_received_commitment_signed() {
					next_funding.retransmit(msgs::NextFundingFlag::CommitmentSigned);
				}

				next_funding
			})
		//   - otherwise:
		//     - MUST NOT include the `next_funding` TLV.
	}

	fn maybe_get_my_current_funding_locked(&self) -> Option<msgs::FundingLocked> {
		self.pending_splice
			.as_ref()
			.and_then(|pending| pending.sent_funding_txid)
			.or_else(|| {
				self.is_our_channel_ready().then(|| self.funding.get_funding_txid()).flatten()
			})
			.map(|txid| {
				let mut funding_locked = msgs::FundingLocked { txid, retransmit_flags: 0 };

				// - if `my_current_funding_locked` is included:
				//   - if `announce_channel` is set for this channel:
				//     - if it has not received `announcement_signatures` for that transaction:
				//       - MUST set the `announcement_signatures` bit to `1` in `retransmit_flags`.
				//     - otherwise:
				//       - MUST set the `announcement_signatures` bit to `0` in `retransmit_flags`.
				if self.context.config.announce_for_forwarding {
					if self.funding.get_funding_txid() != Some(txid)
						|| self.context.announcement_sigs.is_none()
					{
						funding_locked.retransmit(msgs::FundingLockedFlags::AnnouncementSignatures);
					}
				}

				funding_locked
			})
	}

	/// May panic if called on a channel that wasn't immediately-previously
	/// self.remove_uncommitted_htlcs_and_mark_paused()'d
	#[rustfmt::skip]
	fn get_channel_reestablish<L: Logger>(&mut self, logger: &L) -> msgs::ChannelReestablish {
		assert!(self.context.channel_state.is_peer_disconnected());
		assert_ne!(self.context.counterparty_next_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
		// This is generally the first function which gets called on any given channel once we're
		// up and running normally. Thus, we take this opportunity to attempt to resolve the
		// `holder_commitment_point` to get any keys which we are currently missing.
		self.holder_commitment_point.try_resolve_pending(
			&self.context.holder_signer, &self.context.secp_ctx, logger,
		);
		// Prior to static_remotekey, my_current_per_commitment_point was critical to claiming
		// current to_remote balances. However, it no longer has any use, and thus is now simply
		// set to a dummy (but valid, as required by the spec) public key.
		// fuzzing mode marks a subset of pubkeys as invalid so that we can hit "invalid pubkey"
		// branches, but we unwrap it below, so we arbitrarily select a dummy pubkey which is both
		// valid, and valid in fuzzing mode's arbitrary validity criteria:
		let mut pk = [2; 33]; pk[1] = 0xff;
		let dummy_pubkey = PublicKey::from_slice(&pk).unwrap();
		let remote_last_secret = if self.context.counterparty_next_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
			let remote_last_secret = self.context.commitment_secrets.get_secret(self.context.counterparty_next_commitment_transaction_number + 2).unwrap();
			log_trace!(logger, "Enough info to generate a Data Loss Protect with per_commitment_secret {}", log_bytes!(remote_last_secret));
			remote_last_secret
		} else {
			log_info!(logger, "Sending a data_loss_protect with no previous remote per_commitment_secret for channel {}", &self.context.channel_id());
			[0;32]
		};
		let my_current_funding_locked = self.maybe_get_my_current_funding_locked();
		self.context.funding_locked_txid_sent_in_reestablish =
			my_current_funding_locked.as_ref().map(|funding_locked| funding_locked.txid);
		msgs::ChannelReestablish {
			channel_id: self.context.channel_id(),
			// The protocol has two different commitment number concepts - the "commitment
			// transaction number", which starts from 0 and counts up, and the "revocation key
			// index" which starts at INITIAL_COMMITMENT_NUMBER and counts down. We track
			// commitment transaction numbers by the index which will be used to reveal the
			// revocation key for that commitment transaction, which means we have to convert them
			// to protocol-level commitment numbers here...

			// next_local_commitment_number is the next commitment_signed number we expect to
			// receive (indicating if they need to resend one that we missed).
			next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.holder_commitment_point.next_transaction_number(),
			// We have to set next_remote_commitment_number to the next revoke_and_ack we expect to
			// receive, however we track it by the next commitment number for a remote transaction
			// (which is one further, as they always revoke previous commitment transaction, not
			// the one we send) so we have to decrement by 1. Note that if
			// counterparty_next_commitment_transaction_number is INITIAL_COMMITMENT_NUMBER we will have
			// dropped this channel on disconnect as it hasn't yet reached AwaitingChannelReady so we can't
			// overflow here.
			next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.counterparty_next_commitment_transaction_number - 1,
			your_last_per_commitment_secret: remote_last_secret,
			my_current_per_commitment_point: dummy_pubkey,
			next_funding: self.maybe_get_next_funding(),
			my_current_funding_locked,
		}
	}

	/// Builds a [`FundingTemplate`] for splicing or RBF, if the channel state allows it.
	pub fn splice_channel(&self) -> Result<FundingTemplate, APIError> {
		if self.holder_commitment_point.current_point().is_none() {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Channel {} cannot be spliced until a payment is routed",
					self.context.channel_id(),
				),
			});
		}

		if self.quiescent_action.is_some() {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Channel {} cannot be spliced as one is waiting to be negotiated",
					self.context.channel_id(),
				),
			});
		}

		if let Some(pending_splice) = &self.pending_splice {
			if let Some(funding_negotiation) = &pending_splice.funding_negotiation {
				debug_assert!(self.context.channel_state.is_quiescent());
				if funding_negotiation.is_initiator() {
					return Err(APIError::APIMisuseError {
						err: format!(
							"Channel {} cannot be spliced as one is currently being negotiated",
							self.context.channel_id(),
						),
					});
				}
			}
		}

		if !self.context.is_usable() {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Channel {} cannot be spliced as it is either pending open/close",
					self.context.channel_id()
				),
			});
		}

		let spliceable_balance = self.get_next_splice_out_maximum(&self.funding).map_err(|e| {
			APIError::ChannelUnavailable {
				err: format!(
					"Channel {} cannot be spliced at this time: {}",
					self.context.channel_id(),
					e
				),
			}
		})?;

		let (min_rbf_feerate, prior_contribution) = if self.is_rbf_compatible().is_err() {
			// Channel can never RBF (e.g., zero-conf).
			(None, None)
		} else if self.pending_splice.as_ref().is_some_and(|pending_splice| {
			pending_splice.has_confirmed_candidate()
				|| pending_splice.received_funding_txid.is_some()
		}) {
			// The pending candidate can no longer be replaced. Return a fresh template so
			// that any non-overlapping contribution waits for it to lock instead of being
			// presented as an RBF attempt. Submission separately rejects stale RBF templates
			// built before confirmation or receipt of `splice_locked`.
			(None, None)
		} else if let Some(pending_splice) = self.pending_splice.as_ref() {
			// A splice is pending — either a completed negotiation that hasn't locked yet
			// or an in-progress negotiation. In either case, the user's splice will need
			// to satisfy the minimum RBF feerate. When that feerate is unknown (the splice
			// was last written by an LDK version prior to 0.3, which persisted neither it nor
			// our contribution), the minimum RBF feerate is left unset so the new splice is
			// queued and begins as a fresh splice once the pending candidate locks, rather than
			// attempting to replace it.
			//
			// If an in-progress negotiation later fails (e.g., tx_abort), the derived
			// min_rbf_feerate becomes stale, causing a slightly higher feerate than
			// necessary. Call splice_channel again after receiving SpliceNegotiationFailed to get a
			// fresh template without the stale RBF constraint.
			let min_rbf_feerate = pending_splice.min_rbf_feerate();
			let prior = if pending_splice.last_funding_feerate_sat_per_1000_weight.is_some() {
				pending_splice.latest_contribution().cloned()
			} else {
				None
			};
			(min_rbf_feerate, prior)
		} else {
			// No pending splice — fresh splice with no RBF constraint.
			(None, None)
		};

		let funding_txo = self.funding.get_funding_txo().expect("funding_txo should be set");
		let previous_utxo =
			self.funding.get_funding_output().expect("funding_output should be set");
		let shared_input = Input {
			outpoint: funding_txo.into_bitcoin_outpoint(),
			previous_utxo,
			satisfaction_weight: EMPTY_SCRIPT_SIG_WEIGHT + FUNDING_TRANSACTION_WITNESS_WEIGHT,
		};

		Ok(FundingTemplate::new(
			Some(shared_input),
			min_rbf_feerate,
			prior_contribution,
			spliceable_balance,
		))
	}

	/// Returns whether this channel can ever RBF, independent of splice state.
	fn is_rbf_compatible(&self) -> Result<(), String> {
		if self.context.minimum_depth(&self.funding) == Some(0) {
			return Err(format!(
				"Channel {} has option_zeroconf, cannot RBF",
				self.context.channel_id(),
			));
		}
		Ok(())
	}

	/// Whether a committed-but-not-yet-negotiating contribution can replace the pending candidate
	/// via RBF, rather than having to wait for that candidate to lock. Used to classify a queued
	/// contribution's status while it awaits quiescence.
	fn queued_contribution_can_rbf(&self, contribution: &FundingContribution) -> bool {
		let pending_splice = match &self.pending_splice {
			Some(pending_splice) => pending_splice,
			None => return false,
		};
		// A zero-conf channel can never RBF, and a candidate that is already locking can no longer
		// be replaced.
		if self.is_rbf_compatible().is_err() {
			return false;
		}
		if pending_splice.has_confirmed_candidate()
			|| pending_splice.received_funding_txid.is_some()
		{
			return false;
		}
		// The replacement must pay a higher feerate than the most recent round: the one currently
		// under negotiation if any (which is the candidate we would replace once it signs),
		// otherwise the most recently negotiated candidate. The in-flight feerate is fixed when the
		// round starts, so affordability is determinable even before it signs.
		let prev_feerate = match pending_splice.funding_negotiation.as_ref() {
			Some(funding_negotiation) => funding_negotiation.funding_feerate_sat_per_1000_weight(),
			None => match pending_splice.last_funding_feerate_sat_per_1000_weight {
				Some(prev_feerate) => prev_feerate,
				None => return false,
			},
		};
		contribution.feerate() >= PendingFunding::min_rbf_feerate_above(prev_feerate)
	}

	fn can_initiate_rbf(&self) -> Result<FeeRate, String> {
		self.is_rbf_compatible()?;

		let pending_splice = match &self.pending_splice {
			Some(pending_splice) => pending_splice,
			None => {
				return Err(format!(
					"Channel {} has no pending splice to RBF",
					self.context.channel_id(),
				));
			},
		};

		if pending_splice.funding_negotiation.is_some() {
			return Err(format!(
				"Channel {} cannot RBF as a funding negotiation is already in progress",
				self.context.channel_id(),
			));
		}

		if pending_splice.has_confirmed_candidate() {
			return Err(
				"A negotiated splice transaction has already confirmed, cannot RBF".to_owned()
			);
		}

		if pending_splice.received_funding_txid.is_some() {
			return Err(format!(
				"Channel {} counterparty already sent splice_locked, cannot RBF",
				self.context.channel_id(),
			));
		}

		if pending_splice.negotiated_candidates.is_empty() {
			return Err(format!(
				"Channel {} has no negotiated splice candidates to RBF",
				self.context.channel_id(),
			));
		}

		match pending_splice.last_funding_feerate_sat_per_1000_weight {
			Some(prev_feerate) => Ok(PendingFunding::min_rbf_feerate_above(prev_feerate)),
			None => Err(format!(
				"Channel {} has no prior feerate to compute RBF minimum",
				self.context.channel_id(),
			)),
		}
	}

	/// Attempts to adjust the contribution's feerate to the minimum RBF feerate so the splice can
	/// proceed as an RBF immediately rather than waiting for the pending splice to lock.
	/// Returns the adjusted contribution on success, or the original on failure.
	fn maybe_adjust_for_rbf<L: Logger>(
		&self, contribution: FundingContribution, min_rbf_feerate: FeeRate, logger: &L,
	) -> FundingContribution {
		if contribution.feerate() >= min_rbf_feerate {
			return contribution;
		}

		let spliceable_balance = match self.get_next_splice_out_maximum(&self.funding) {
			Ok(balance) => balance,
			Err(_) => return contribution,
		};

		if let Err(e) =
			contribution.net_value_for_initiator_at_feerate(min_rbf_feerate, spliceable_balance)
		{
			log_info!(logger, "Cannot adjust to minimum RBF feerate {}: {}", min_rbf_feerate, e,);
			return contribution;
		}

		log_info!(
			logger,
			"Adjusting contribution feerate from {} to minimum RBF feerate {}",
			contribution.feerate(),
			min_rbf_feerate,
		);
		contribution
			.for_initiator_at_feerate(min_rbf_feerate, spliceable_balance)
			.expect("feerate compatibility already checked")
	}

	pub fn funding_contributed<F: FeeEstimator, L: Logger>(
		&mut self, contribution: FundingContribution, locktime: LockTime,
		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<Option<msgs::Stfu>, QuiescentError> {
		debug_assert!(contribution.is_splice());

		// Refuse the contribution if one of ours is already queued or under negotiation. Like any
		// failure, the refusal releases what the contribution reserved itself.
		let already_contributing = match self.quiescent_action.as_ref() {
			Some(QuiescentAction::Splice { .. }) => true,
			#[cfg(any(test, fuzzing, feature = "_test_utils"))]
			Some(QuiescentAction::DoNothing) => unreachable!(),
			None => self
				.pending_splice
				.as_ref()
				.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
				.is_some_and(|funding_negotiation| funding_negotiation.is_initiator()),
		};
		if already_contributing {
			return Err(match contribution.unique_contributions() {
				None => QuiescentError::DoNothing,
				Some((inputs, outputs)) => QuiescentError::DiscardFunding {
					inputs,
					outputs: outputs
						.into_iter()
						.map(|output| output.script_pubkey.clone())
						.collect(),
				},
			});
		}

		// Reject the contribution if its record of inherited inputs and outputs names anything no
		// live splice attempt still commits to: it was built against splice state that no longer
		// exists (a stale template), and the caller should build a new contribution from a fresh
		// one. The rejection releases what the contribution reserved itself.
		let (committed_inputs, committed_output_scripts) = self
			.pending_splice
			.as_ref()
			.map(|pending_splice| pending_splice.committed_funding_parts())
			.unwrap_or_default();
		if contribution.is_stale(&committed_inputs, &committed_output_scripts) {
			log_error!(
				logger,
				"Channel {} rejecting stale funding contribution: its inherited inputs and outputs no longer match the pending splice state; build a new contribution from a fresh FundingTemplate",
				self.context.channel_id(),
			);
			return Err(QuiescentError::FailSplice(
				SpliceFundingFailed::from_contribution(contribution),
				NegotiationFailureReason::ContributionInvalid,
			));
		}

		let our_funding_contribution = contribution.net_value();
		let unsigned_contribution = our_funding_contribution.unsigned_abs();
		if let Err(e) = self.get_next_splice_out_maximum(&self.funding)
			.and_then(|splice_max| splice_max
				.to_sat()
				.checked_add_signed(our_funding_contribution.to_sat())
				.ok_or(format!("Our splice-out value of {unsigned_contribution} is greater than the maximum {splice_max}"))
			)
		{
			log_error!(logger, "Channel {} cannot be funded: {}", self.context.channel_id(), e);
			return Err(QuiescentError::FailSplice(
				SpliceFundingFailed::from_contribution(contribution),
				NegotiationFailureReason::ContributionInvalid,
			));
		}

		if let Some(pending_splice) = self.pending_splice.as_ref() {
			if !pending_splice.is_rbf_feerate_sufficient(
				contribution.feerate().to_sat_per_kwu() as u32,
				fee_estimator,
			) {
				log_error!(
					logger,
					"Channel {} RBF feerate {} below fee estimator minimum",
					self.context.channel_id(),
					contribution.feerate(),
				);
				return Err(QuiescentError::FailSplice(
					SpliceFundingFailed::from_contribution(contribution),
					NegotiationFailureReason::FeeRateTooLow,
				));
			}
		}

		// If a pending splice exists with negotiated candidates, attempt to adjust the
		// contribution's feerate to the minimum RBF feerate so it can proceed as an RBF immediately
		// rather than waiting for the splice to lock. We may only queue it for a later fresh splice
		// if it does not reuse any inputs or outputs committed to pending rounds.
		let (contribution, rbf_failure_reason) = if self.pending_splice.is_some() {
			match self.can_initiate_rbf() {
				Ok(min_rbf_feerate) => {
					let contribution =
						self.maybe_adjust_for_rbf(contribution, min_rbf_feerate, logger);
					let failure_reason = if contribution.feerate() < min_rbf_feerate {
						Some(NegotiationFailureReason::FeeRateTooLow)
					} else {
						None
					};
					(contribution, failure_reason)
				},
				Err(e) => {
					log_info!(
						logger,
						"Cannot initiate splice RBF for channel {}: {}",
						self.context.channel_id(),
						e,
					);
					(contribution, Some(NegotiationFailureReason::CannotInitiateRbf))
				},
			}
		} else {
			(contribution, None)
		};

		if let Some(reason) = rbf_failure_reason {
			let can_queue_for_fresh_splice =
				self.pending_splice.as_ref().map_or(true, |pending_splice| {
					pending_splice.can_queue_contribution_for_fresh_splice(&contribution)
				});
			if !can_queue_for_fresh_splice {
				return Err(QuiescentError::FailSplice(
					SpliceFundingFailed::from_contribution(contribution),
					reason,
				));
			}
		}

		// A queued splice never coexists with a negotiation we initiated: we return early above if
		// one is already in flight, and a queued action is cleared the moment it becomes our
		// negotiation at quiescence. It may coexist with a counterparty-initiated negotiation (e.g.
		// queuing our own contribution while accepting their splice), so we only rule out our own.
		debug_assert!(
			self.pending_splice
				.as_ref()
				.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
				.map_or(true, |funding_negotiation| !funding_negotiation.is_initiator()),
			"A queued splice must not coexist with a funding negotiation we initiated",
		);

		self.propose_quiescence(logger, QuiescentAction::Splice { contribution, locktime })
	}

	/// Returns a reference to the funding contribution queued by a pending [`QuiescentAction`],
	/// if any.
	fn queued_funding_contribution(&self) -> Option<&FundingContribution> {
		match &self.quiescent_action {
			Some(QuiescentAction::Splice { contribution, .. }) => Some(contribution),
			_ => None,
		}
	}

	/// Consumes and returns the funding contribution from the pending [`QuiescentAction`], if any.
	fn take_queued_funding_contribution(&mut self) -> Option<FundingContribution> {
		match &self.quiescent_action {
			Some(QuiescentAction::Splice { .. }) => match self.quiescent_action.take() {
				Some(QuiescentAction::Splice { contribution, .. }) => Some(contribution),
				_ => unreachable!(),
			},
			_ => None,
		}
	}

	fn send_splice_init(
		&mut self, context: FundingNegotiationContext, contribution: FundingContribution,
	) -> msgs::SpliceInit {
		debug_assert!(self.pending_splice.is_none());
		// Rotate the funding pubkey using the prev_funding_txid as a tweak
		let prev_funding_txid = self.funding.get_funding_txid();
		let funding_pubkey = match prev_funding_txid {
			None => {
				debug_assert!(false);
				self.funding.get_holder_pubkeys().funding_pubkey
			},
			Some(prev_funding_txid) => self
				.context
				.holder_signer
				.new_funding_pubkey(prev_funding_txid, &self.context.secp_ctx),
		};

		let funding_feerate_per_kw = context.funding_feerate_sat_per_1000_weight;
		let funding_contribution_satoshis = context.our_funding_contribution.to_sat();
		let locktime = context.funding_tx_locktime.to_consensus_u32();

		let funding_negotiation =
			FundingNegotiation::AwaitingAck { context, new_holder_funding_key: funding_pubkey };
		self.pending_splice = Some(PendingFunding {
			funding_negotiation: Some(funding_negotiation),
			negotiation_contribution: Some(contribution),
			negotiated_candidates: vec![],
			sent_funding_txid: None,
			received_funding_txid: None,
			last_funding_feerate_sat_per_1000_weight: None,
		});

		msgs::SpliceInit {
			channel_id: self.context.channel_id,
			funding_contribution_satoshis,
			funding_feerate_per_kw,
			locktime,
			funding_pubkey,
			require_confirmed_inputs: None,
		}
	}

	fn send_tx_init_rbf(
		&mut self, context: FundingNegotiationContext, contribution: FundingContribution,
	) -> msgs::TxInitRbf {
		let pending_splice =
			self.pending_splice.as_mut().expect("pending_splice should exist for RBF");
		debug_assert!(!pending_splice.negotiated_candidates.is_empty());
		debug_assert!(
			pending_splice.funding_negotiation.is_none(),
			"A new RBF cannot begin while another funding negotiation is in progress",
		);

		let new_holder_funding_key = pending_splice
			.negotiated_candidates
			.first()
			.unwrap()
			.funding
			.get_holder_pubkeys()
			.funding_pubkey;

		let funding_feerate_per_kw = context.funding_feerate_sat_per_1000_weight;
		let funding_contribution_satoshis = context.our_funding_contribution.to_sat();
		let locktime = context.funding_tx_locktime.to_consensus_u32();

		pending_splice.funding_negotiation =
			Some(FundingNegotiation::AwaitingAck { context, new_holder_funding_key });
		pending_splice.negotiation_contribution = Some(contribution);

		msgs::TxInitRbf {
			channel_id: self.context.channel_id,
			locktime,
			feerate_sat_per_1000_weight: funding_feerate_per_kw,
			funding_output_contribution: Some(funding_contribution_satoshis),
		}
	}

	pub fn cancel_funding_contributed(&mut self) -> Result<InteractiveTxMsgError, APIError> {
		if matches!(self.quiescent_action, Some(QuiescentAction::Splice { .. })) {
			let splice_funding_failed = self.abandon_quiescent_action();
			debug_assert!(splice_funding_failed.is_some());
			let str = "Manually canceled funding contribution";
			let err = if self.context.channel_state.is_local_stfu_sent()
				&& !self.context.channel_state.is_remote_stfu_sent()
			{
				// If we've already sent `stfu` and haven't received the counterparty's yet, we know
				// it corresponds to our action.
				ChannelError::WarnAndDisconnect(str.into())
			} else {
				// We don't need to send `tx_abort` because our action still pending means we're not
				// quiescent for it.
				ChannelError::Ignore(str.into())
			};
			return Ok(InteractiveTxMsgError::new(err, splice_funding_failed)
				.with_negotiation_failure_reason(NegotiationFailureReason::LocallyCanceled));
		}

		let funding_negotiation = self
			.pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref());
		let Some(funding_negotiation) = funding_negotiation else {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Channel {} does not have a pending splice negotiation",
					self.context.channel_id()
				),
			});
		};

		let made_contribution = match funding_negotiation {
			FundingNegotiation::AwaitingAck { context, .. } => {
				context.contributed_inputs().next().is_some()
					|| context.contributed_outputs().next().is_some()
			},
			FundingNegotiation::ConstructingTransaction { interactive_tx_constructor, .. } => {
				interactive_tx_constructor.contributed_inputs().next().is_some()
					|| interactive_tx_constructor.contributed_outputs().next().is_some()
			},
			FundingNegotiation::AwaitingSignatures { .. } => self
				.context
				.interactive_tx_signing_session
				.as_ref()
				.expect("We have a pending splice awaiting signatures")
				.has_local_contribution(),
		};
		if !made_contribution {
			return Err(APIError::APIMisuseError {
				err: format!(
					"Channel {} has a pending splice negotiation with no contribution made",
					self.context.channel_id()
				),
			});
		}

		// We typically don't reset the pending funding negotiation when we're in
		// [`FundingNegotiation::AwaitingSignatures`] since we're able to resume it on
		// re-establishment, so we still need to handle this case separately if the user wishes to
		// cancel. If they've yet to call [`Channel::funding_transaction_signed`], then we can
		// guarantee to never have sent any signatures to the counterparty, or have processed any
		// signatures from them.
		if matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures { .. }) {
			let already_signed = self
				.context
				.interactive_tx_signing_session
				.as_ref()
				.expect("We have a pending splice awaiting signatures")
				.has_holder_witnesses();
			if already_signed {
				return Err(APIError::APIMisuseError {
					err: format!(
						"Channel {} has pending splice negotiation that was already signed",
						self.context.channel_id(),
					),
				});
			}
		}

		debug_assert!(self.context.channel_state.is_quiescent());
		let (splice_funding_failed, splice_funding_negotiated) = self.reset_pending_splice_state();
		debug_assert!(splice_funding_negotiated.is_none());
		debug_assert!(splice_funding_failed.is_some());
		Ok(InteractiveTxMsgError::new(
			ChannelError::Abort(AbortReason::ManualIntervention),
			splice_funding_failed,
		)
		.with_negotiation_failure_reason(NegotiationFailureReason::LocallyCanceled))
	}

	/// Checks during handling splice_init
	pub fn validate_splice_init(&self, msg: &msgs::SpliceInit) -> Result<(), ChannelError> {
		// - If it has received shutdown:
		//   MUST send a warning and close the connection or send an error
		//   and fail the channel.
		if !self.context.is_live() {
			return Err(ChannelError::WarnAndDisconnect(
				"Splicing requested on a channel that is not live".to_owned(),
			));
		}

		if !self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Quiescence needed to splice".to_owned()));
		}

		// Check if a splice has been initiated already.
		if self.pending_splice.is_some() {
			return Err(ChannelError::WarnAndDisconnect(format!(
				"Channel {} already has a splice pending",
				self.context.channel_id(),
			)));
		}

		let their_funding_contribution = SignedAmount::from_sat(msg.funding_contribution_satoshis);
		if their_funding_contribution == SignedAmount::ZERO {
			return Err(ChannelError::WarnAndDisconnect(format!(
				"Channel {} cannot be spliced; they are the initiator, and their contribution is zero",
				self.context.channel_id(),
			)));
		}

		if self.holder_commitment_point.current_point().is_none() {
			return Err(ChannelError::Abort(AbortReason::InternalError(
				"Commitment point needs to be advanced once before spliced".into(),
			)));
		}

		Ok(())
	}

	fn validate_splice_contributions(
		&self, our_funding_contribution: SignedAmount, their_funding_contribution: SignedAmount,
		counterparty_funding_pubkey: PublicKey, our_new_holder_keys: ChannelPublicKeys,
		min_funding_satoshis: u64,
	) -> Result<FundingScope, String> {
		let candidate_scope = FundingScope::for_splice(
			&self.funding,
			self.context(),
			our_funding_contribution,
			their_funding_contribution,
			counterparty_funding_pubkey,
			our_new_holder_keys,
			min_funding_satoshis,
		)?;

		let (post_splice_holder_balance, post_splice_counterparty_balance) =
			self.get_holder_counterparty_balances_floor_incl_fee(&candidate_scope)?;

		let holder_selected_channel_reserve =
			Amount::from_sat(candidate_scope.holder_selected_channel_reserve_satoshis);
		let counterparty_selected_channel_reserve = Amount::from_sat(
			candidate_scope.counterparty_selected_channel_reserve_satoshis.expect("Reserve is set"),
		);

		// We allow parties to draw from their previous reserve, as long as they satisfy their v2 reserve
		if our_funding_contribution != SignedAmount::ZERO {
			post_splice_holder_balance.checked_sub(counterparty_selected_channel_reserve).ok_or(
				format!(
					"Our post-splice channel balance {} is smaller than their selected v2 reserve {}",
					post_splice_holder_balance,
					counterparty_selected_channel_reserve,
				),
			)?;
		}

		if their_funding_contribution != SignedAmount::ZERO {
			post_splice_counterparty_balance.checked_sub(holder_selected_channel_reserve).ok_or(
				format!(
					"Their post-splice channel balance {} is smaller than our selected v2 reserve {}",
					post_splice_counterparty_balance,
					holder_selected_channel_reserve,
				),
			)?;
		}

		#[cfg(debug_assertions)]
		{
			let (old_holder_balance_msat, old_counterparty_balance_msat) =
				*self.funding.holder_prev_commitment_tx_balance.lock().unwrap();
			let (new_holder_balance_msat, new_counterparty_balance_msat) =
				*candidate_scope.holder_prev_commitment_tx_balance.lock().unwrap();
			if new_holder_balance_msat < counterparty_selected_channel_reserve.to_sat() * 1000 {
				debug_assert_eq!(new_holder_balance_msat, old_holder_balance_msat);
			}
			if new_counterparty_balance_msat < holder_selected_channel_reserve.to_sat() * 1000 {
				debug_assert_eq!(new_counterparty_balance_msat, old_counterparty_balance_msat);
			}
		}
		#[cfg(debug_assertions)]
		{
			let (old_holder_balance_msat, old_counterparty_balance_msat) =
				*self.funding.counterparty_prev_commitment_tx_balance.lock().unwrap();
			let (new_holder_balance_msat, new_counterparty_balance_msat) =
				*candidate_scope.counterparty_prev_commitment_tx_balance.lock().unwrap();
			if new_holder_balance_msat < counterparty_selected_channel_reserve.to_sat() * 1000 {
				debug_assert_eq!(new_holder_balance_msat, old_holder_balance_msat);
			}
			if new_counterparty_balance_msat < holder_selected_channel_reserve.to_sat() * 1000 {
				debug_assert_eq!(new_counterparty_balance_msat, old_counterparty_balance_msat);
			}
		}

		Ok(candidate_scope)
	}

	fn resolve_queued_contribution<L: Logger>(
		&self, feerate: FeeRate, logger: &L,
	) -> Result<(Option<SignedAmount>, Option<Amount>), ChannelError> {
		let spliceable_balance = self
			.get_next_splice_out_maximum(&self.funding)
			.map_err(|e| {
				log_info!(
					logger,
					"Cannot compute holder balance for channel {}: {}; \
						 proceeding without contribution",
					self.context.channel_id(),
					e,
				);
			})
			.ok();

		let net_value = match spliceable_balance.and_then(|_| self.queued_funding_contribution()) {
			Some(c) => {
				match c.net_value_for_acceptor_at_feerate(feerate, spliceable_balance.unwrap()) {
					Ok(net_value) => Some(net_value),
					Err(FeeRateAdjustmentError::FeeRateTooHigh { .. }) => {
						return Err(ChannelError::Abort(AbortReason::FeeRateTooHigh));
					},
					Err(e) => {
						log_info!(
							logger,
							"Cannot accommodate initiator's feerate ({}) for channel {}: {}",
							feerate,
							self.context.channel_id(),
							e,
						);
						None
					},
				}
			},
			None => None,
		};

		Ok((net_value, spliceable_balance))
	}

	pub(crate) fn splice_init<ES: EntropySource, L: Logger>(
		&mut self, msg: &msgs::SpliceInit, entropy_source: &ES, holder_node_id: &PublicKey,
		min_funding_satoshis: u64, logger: &L,
	) -> Result<msgs::SpliceAck, InteractiveTxMsgError> {
		self.validate_splice_init(msg).map_err(|e| self.quiescent_negotiation_err(e))?;

		let feerate = FeeRate::from_sat_per_kwu(msg.funding_feerate_per_kw as u64);
		let (queued_net_value, holder_balance) = self
			.resolve_queued_contribution(feerate, logger)
			.map_err(|e| self.quiescent_negotiation_err(e))?;

		let our_funding_contribution = queued_net_value.unwrap_or(SignedAmount::ZERO);
		let their_funding_contribution = SignedAmount::from_sat(msg.funding_contribution_satoshis);

		// Rotate the pubkeys using the prev_funding_txid as a tweak
		let prev_funding_txid = self.funding.get_funding_txid();
		let funding_pubkey = match prev_funding_txid {
			None => {
				debug_assert!(false);
				self.funding.get_holder_pubkeys().funding_pubkey
			},
			Some(prev_funding_txid) => self
				.context
				.holder_signer
				.new_funding_pubkey(prev_funding_txid, &self.context.secp_ctx),
		};
		let mut holder_pubkeys = self.funding.get_holder_pubkeys().clone();
		holder_pubkeys.funding_pubkey = funding_pubkey;

		let splice_funding = self
			.validate_splice_contributions(
				our_funding_contribution,
				their_funding_contribution,
				msg.funding_pubkey,
				holder_pubkeys,
				min_funding_satoshis,
			)
			.map_err(|e| {
				self.quiescent_negotiation_err(ChannelError::Abort(
					AbortReason::InvalidContribution(e),
				))
			})?;

		// Adjust for the feerate and clone so we can store it for future RBF re-use.
		let (adjusted_contribution, our_funding_inputs, our_funding_outputs) =
			if queued_net_value.is_some() {
				let adjusted_contribution = self
					.take_queued_funding_contribution()
					.expect("queued_funding_contribution was Some")
					.for_acceptor_at_feerate(feerate, holder_balance.unwrap())
					.expect("feerate compatibility already checked");
				let (inputs, outputs) = adjusted_contribution.clone().into_tx_parts();
				(Some(adjusted_contribution), inputs, outputs)
			} else {
				(None, Default::default(), Default::default())
			};

		log_info!(
			logger,
			"Starting splice funding negotiation for channel {} after receiving splice_init; new channel value: {} sats (old: {} sats)",
			self.context.channel_id,
			splice_funding.get_value_satoshis(),
			self.funding.get_value_satoshis(),
		);

		let new_funding_pubkey = splice_funding.get_holder_pubkeys().funding_pubkey;
		let prev_funding_input = self.funding.to_splice_funding_input();
		let funding_negotiation = FundingNegotiation::for_acceptor(
			splice_funding,
			&self.context,
			entropy_source,
			holder_node_id,
			our_funding_contribution,
			prev_funding_input,
			msg.locktime,
			msg.funding_feerate_per_kw,
			our_funding_inputs,
			our_funding_outputs,
		);
		self.pending_splice = Some(PendingFunding {
			funding_negotiation: Some(funding_negotiation),
			negotiation_contribution: adjusted_contribution,
			negotiated_candidates: Vec::new(),
			received_funding_txid: None,
			sent_funding_txid: None,
			last_funding_feerate_sat_per_1000_weight: None,
		});

		Ok(msgs::SpliceAck {
			channel_id: self.context.channel_id,
			funding_contribution_satoshis: our_funding_contribution.to_sat(),
			funding_pubkey: new_funding_pubkey,
			require_confirmed_inputs: None,
		})
	}

	/// Checks during handling tx_init_rbf for an existing splice
	fn validate_tx_init_rbf<F: FeeEstimator>(
		&self, msg: &msgs::TxInitRbf, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<(ChannelPublicKeys, PublicKey), ChannelError> {
		if !self.context.is_live() {
			return Err(ChannelError::WarnAndDisconnect(
				"RBF requested on a channel that is not live".to_owned(),
			));
		}
		if !self.context.channel_state.is_quiescent() {
			return Err(ChannelError::WarnAndDisconnect("Quiescence needed for RBF".to_owned()));
		}

		if self.holder_commitment_point.current_point().is_none() {
			return Err(ChannelError::Abort(AbortReason::InternalError(
				"Commitment point needs to be advanced once before RBF".into(),
			)));
		}

		self.is_rbf_compatible()
			.map_err(|msg| ChannelError::Abort(AbortReason::RbfUnavailable(msg)))?;

		let (pending_splice, last_candidate) = self
			.pending_splice
			.as_ref()
			.filter(|pending_splice| !pending_splice.negotiated_candidates.is_empty())
			.map(|pending_splice| {
				(
					pending_splice,
					pending_splice.negotiated_candidates.last().expect("checked above"),
				)
			})
			.ok_or_else(|| {
				ChannelError::Abort(AbortReason::RbfUnavailable(
					"No pending splice available to RBF".into(),
				))
			})?;

		if pending_splice.funding_negotiation.is_some() {
			return Err(ChannelError::WarnAndDisconnect(
				"Received tx_init_rbf while a funding negotiation is already in progress"
					.to_owned(),
			));
		}

		if pending_splice.received_funding_txid.is_some() {
			return Err(ChannelError::Abort(AbortReason::RbfUnavailable(
				"Already received splice_locked".into(),
			)));
		}

		if pending_splice.has_confirmed_candidate() {
			return Err(ChannelError::Abort(AbortReason::RbfUnavailable(
				"A negotiated splice transaction has already confirmed".into(),
			)));
		}

		let prev_feerate =
			pending_splice.last_funding_feerate_sat_per_1000_weight.unwrap_or_else(|| {
				fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::UrgentOnChainSweep)
			});
		let new_feerate = FeeRate::from_sat_per_kwu(msg.feerate_sat_per_1000_weight as u64);
		if new_feerate < PendingFunding::min_rbf_feerate_above(prev_feerate) {
			return Err(ChannelError::Abort(AbortReason::InsufficientRbfFeerate));
		}

		if !pending_splice.is_rbf_feerate_sufficient(msg.feerate_sat_per_1000_weight, fee_estimator)
		{
			return Err(ChannelError::Abort(AbortReason::InsufficientRbfFeerate));
		}

		// Reuse funding pubkeys from the last negotiated candidate since all RBF candidates
		// for the same splice share the same funding output script.
		Ok((
			last_candidate.funding.get_holder_pubkeys().clone(),
			*last_candidate.funding.counterparty_funding_pubkey(),
		))
	}

	pub(crate) fn tx_init_rbf<ES: EntropySource, F: FeeEstimator, L: Logger>(
		&mut self, msg: &msgs::TxInitRbf, entropy_source: &ES, holder_node_id: &PublicKey,
		fee_estimator: &LowerBoundedFeeEstimator<F>, min_funding_satoshis: u64, logger: &L,
	) -> Result<msgs::TxAckRbf, InteractiveTxMsgError> {
		let (holder_pubkeys, counterparty_funding_pubkey) = self
			.validate_tx_init_rbf(msg, fee_estimator)
			.map_err(|e| self.quiescent_negotiation_err(e))?;

		let feerate = FeeRate::from_sat_per_kwu(msg.feerate_sat_per_1000_weight as u64);
		let (queued_net_value, holder_balance) = self
			.resolve_queued_contribution(feerate, logger)
			.map_err(|e| self.quiescent_negotiation_err(e))?;

		// If no queued contribution, try prior contribution from previous negotiation.
		// Failing here means the RBF would erase our splice — reject it.
		let prior_net_value = if queued_net_value.is_some() {
			None
		} else if let Some(prior) = self
			.pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.latest_contribution())
		{
			let net_value = holder_balance
				.ok_or_else(|| ChannelError::Abort(AbortReason::InsufficientRbfFeerate))
				.and_then(|holder_balance| {
					prior
						.net_value_for_acceptor_at_feerate(feerate, holder_balance)
						.map_err(|_| ChannelError::Abort(AbortReason::InsufficientRbfFeerate))
				})
				.map_err(|e| self.quiescent_negotiation_err(e))?;
			Some(net_value)
		} else {
			None
		};

		let our_funding_contribution = queued_net_value.or(prior_net_value);
		let our_funding_contribution = our_funding_contribution.unwrap_or(SignedAmount::ZERO);

		let their_funding_contribution = match msg.funding_output_contribution {
			Some(value) => SignedAmount::from_sat(value),
			None => SignedAmount::ZERO,
		};

		let rbf_funding = self
			.validate_splice_contributions(
				our_funding_contribution,
				their_funding_contribution,
				counterparty_funding_pubkey,
				holder_pubkeys,
				min_funding_satoshis,
			)
			.map_err(|e| {
				self.quiescent_negotiation_err(ChannelError::Abort(
					AbortReason::InvalidContribution(e),
				))
			})?;

		// Consume the appropriate contribution source.
		let (our_funding_inputs, our_funding_outputs) = if queued_net_value.is_some() {
			let adjusted_contribution = self
				.take_queued_funding_contribution()
				.expect("queued_funding_contribution was Some")
				.for_acceptor_at_feerate(feerate, holder_balance.unwrap())
				.expect("feerate compatibility already checked");
			self.pending_splice
				.as_mut()
				.expect("pending_splice is Some")
				.negotiation_contribution = Some(adjusted_contribution.clone());
			adjusted_contribution.into_tx_parts()
		} else if prior_net_value.is_some() {
			let prior_contribution = self
				.pending_splice
				.as_ref()
				.expect("pending_splice is Some")
				.latest_contribution()
				.expect("prior_net_value was Some")
				.clone();
			// The carried-forward contribution only reuses what the prior round committed to, so
			// record everything as inherited: a failure of the new round then releases nothing, as
			// the prior round's transaction may still confirm.
			let pending_components =
				PendingFundingComponents::from_contribution(&prior_contribution);
			let adjusted_contribution = prior_contribution
				.for_acceptor_at_feerate(feerate, holder_balance.unwrap())
				.expect("feerate compatibility already checked")
				.with_pending_components(pending_components);
			self.pending_splice
				.as_mut()
				.expect("pending_splice is Some")
				.negotiation_contribution = Some(adjusted_contribution.clone());
			adjusted_contribution.into_tx_parts()
		} else {
			Default::default()
		};

		log_info!(
			logger,
			"Starting RBF funding negotiation for channel {} after receiving tx_init_rbf; channel value: {} sats",
			self.context.channel_id,
			rbf_funding.get_value_satoshis(),
		);

		let prev_funding_input = self.funding.to_splice_funding_input();
		let funding_negotiation = FundingNegotiation::for_acceptor(
			rbf_funding,
			&self.context,
			entropy_source,
			holder_node_id,
			our_funding_contribution,
			prev_funding_input,
			msg.locktime,
			msg.feerate_sat_per_1000_weight,
			our_funding_inputs,
			our_funding_outputs,
		);
		let pending_splice = self.pending_splice.as_mut().expect("pending_splice should exist");
		pending_splice.funding_negotiation = Some(funding_negotiation);

		Ok(msgs::TxAckRbf {
			channel_id: self.context.channel_id,
			funding_output_contribution: if our_funding_contribution != SignedAmount::ZERO {
				Some(our_funding_contribution.to_sat())
			} else {
				None
			},
		})
	}

	fn validate_tx_ack_rbf(
		&self, msg: &msgs::TxAckRbf, min_funding_satoshis: u64,
	) -> Result<FundingScope, ChannelError> {
		let pending_splice = self
			.pending_splice
			.as_ref()
			.ok_or_else(|| ChannelError::Ignore("Channel is not in pending splice".to_owned()))?;

		let (funding_negotiation_context, _) = pending_splice.awaiting_ack_context("tx_ack_rbf")?;

		let our_funding_contribution = funding_negotiation_context.our_funding_contribution;
		let their_funding_contribution = match msg.funding_output_contribution {
			Some(value) => SignedAmount::from_sat(value),
			None => SignedAmount::ZERO,
		};

		let last_candidate = pending_splice.negotiated_candidates.last().ok_or_else(|| {
			ChannelError::Abort(AbortReason::RbfUnavailable(
				"No pending splice available to RBF".into(),
			))
		})?;
		let holder_pubkeys = last_candidate.funding.get_holder_pubkeys().clone();
		let counterparty_funding_pubkey = *last_candidate.funding.counterparty_funding_pubkey();

		let new_funding = self
			.validate_splice_contributions(
				our_funding_contribution,
				their_funding_contribution,
				counterparty_funding_pubkey,
				holder_pubkeys,
				min_funding_satoshis,
			)
			.map_err(|e| ChannelError::Abort(AbortReason::InvalidContribution(e)))?;

		Ok(new_funding)
	}

	pub(crate) fn tx_ack_rbf<ES: EntropySource, L: Logger>(
		&mut self, msg: &msgs::TxAckRbf, entropy_source: &ES, holder_node_id: &PublicKey,
		min_funding_satoshis: u64, logger: &L,
	) -> Result<Option<InteractiveTxMessageSend>, ChannelError> {
		let rbf_funding = self.validate_tx_ack_rbf(msg, min_funding_satoshis)?;

		log_info!(
			logger,
			"Starting RBF funding negotiation for channel {} after receiving tx_ack_rbf; channel value: {} sats",
			self.context.channel_id,
			rbf_funding.get_value_satoshis(),
		);

		let pending_splice = self
			.pending_splice
			.as_mut()
			.expect("pending_splice existence validated in validate_tx_ack_rbf");
		let funding_negotiation_context = pending_splice
			.take_awaiting_ack_context("tx_ack_rbf")
			.expect("awaiting ack state validated in validate_tx_ack_rbf");

		let (funding_negotiation, tx_msg_opt) = FundingNegotiation::for_initiator(
			rbf_funding,
			&self.context,
			funding_negotiation_context,
			entropy_source,
			holder_node_id,
		);
		pending_splice.funding_negotiation = Some(funding_negotiation);

		Ok(tx_msg_opt)
	}

	pub(crate) fn splice_ack<ES: EntropySource, L: Logger>(
		&mut self, msg: &msgs::SpliceAck, entropy_source: &ES, holder_node_id: &PublicKey,
		min_funding_satoshis: u64, logger: &L,
	) -> Result<Option<InteractiveTxMessageSend>, ChannelError> {
		let splice_funding = self.validate_splice_ack(msg, min_funding_satoshis)?;

		log_info!(
			logger,
			"Starting splice funding negotiation for channel {} after receiving splice_ack; new channel value: {} sats (old: {} sats)",
			self.context.channel_id,
			splice_funding.get_value_satoshis(),
			self.funding.get_value_satoshis(),
		);

		debug_assert!(self.context.interactive_tx_signing_session.is_none());

		let pending_splice = self
			.pending_splice
			.as_mut()
			.expect("pending_splice existence validated in validate_splice_ack");
		let funding_negotiation_context = pending_splice
			.take_awaiting_ack_context("splice_ack")
			.expect("awaiting ack state validated in validate_splice_ack");

		let (funding_negotiation, tx_msg_opt) = FundingNegotiation::for_initiator(
			splice_funding,
			&self.context,
			funding_negotiation_context,
			entropy_source,
			holder_node_id,
		);
		pending_splice.funding_negotiation = Some(funding_negotiation);

		Ok(tx_msg_opt)
	}

	fn validate_splice_ack(
		&self, msg: &msgs::SpliceAck, min_funding_satoshis: u64,
	) -> Result<FundingScope, ChannelError> {
		let pending_splice = self
			.pending_splice
			.as_ref()
			.ok_or_else(|| ChannelError::Ignore("Channel is not in pending splice".to_owned()))?;

		let (funding_negotiation_context, new_holder_funding_key) =
			pending_splice.awaiting_ack_context("splice_ack")?;

		let our_funding_contribution = funding_negotiation_context.our_funding_contribution;
		let their_funding_contribution = SignedAmount::from_sat(msg.funding_contribution_satoshis);

		let mut new_keys = self.funding.get_holder_pubkeys().clone();
		new_keys.funding_pubkey = *new_holder_funding_key;

		let new_funding = self
			.validate_splice_contributions(
				our_funding_contribution,
				their_funding_contribution,
				msg.funding_pubkey,
				new_keys,
				min_funding_satoshis,
			)
			.map_err(|e| ChannelError::Abort(AbortReason::InvalidContribution(e)))?;

		Ok(new_funding)
	}

	/// The balances returned here should only be used to check that both parties still hold
	/// their respective reserves *after* a splice. This function also checks that both local
	/// and remote commitments still have at least one output after the splice, which is
	/// particularly relevant for zero-reserve channels.
	///
	/// Do NOT use this to determine how much the holder can splice out of the channel. The balance
	/// of the holder after a splice is not necessarily equal to the funds they can splice out
	/// of the channel due to the v2 reserve, and the zero-reserve-at-least-one-output
	/// requirements. Note you cannot simply subtract out the reserve, as splicing funds out
	/// of the channel changes the reserve the holder must keep in the channel.
	///
	/// See [`FundedChannel::get_next_splice_out_maximum`] for the maximum value of the next
	/// splice out of the holder's balance.
	fn get_holder_counterparty_balances_floor_incl_fee(
		&self, funding: &FundingScope,
	) -> Result<(Amount, Amount), String> {
		// Make sure that that the funder of the channel can pay the transaction fees for an additional
		// nondust HTLC on the channel.
		let addl_nondust_htlc_count = 1;
		// We are not interested in dust exposure
		let dust_exposure_limiting_feerate = None;

		// Different dust limits on the local and remote commitments cause the commitment
		// transaction fee to be different depending on the commitment, so we grab the floor
		// of both balances across both commitments here.
		//
		// `get_channel_stats` also checks for at least one output on the commitment given
		// these parameters. This is particularly relevant for zero-reserve channels.
		//
		// This "at-least-one-output" check is why we still run both checks on
		// zero-fee-commitment channels, even though those channels don't suffer from the
		// commitment transaction fee asymmetry.
		let (local_stats, _local_htlcs) = self
			.context
			.get_next_local_commitment_stats(
				funding,
				None, // htlc_candidate
				NextCommitmentView::ValidatingOwnUpdate,
				addl_nondust_htlc_count,
				self.context.feerate_per_kw,
				true,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| "Balance exhausted on local commitment")?;

		let (remote_stats, _remote_htlcs) = self
			.context
			.get_next_remote_commitment_stats(
				funding,
				None, // htlc_candidate
				NextCommitmentView::ValidatingOwnUpdate,
				addl_nondust_htlc_count,
				self.context.feerate_per_kw,
				true,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| "Balance exhausted on remote commitment")?;

		let holder_balance_floor = Amount::from_sat(
			cmp::min(
				local_stats.commitment_stats.holder_balance_msat,
				remote_stats.commitment_stats.holder_balance_msat,
			) / 1000,
		);
		let counterparty_balance_floor = Amount::from_sat(
			cmp::min(
				local_stats.commitment_stats.counterparty_balance_msat,
				remote_stats.commitment_stats.counterparty_balance_msat,
			) / 1000,
		);

		Ok((holder_balance_floor, counterparty_balance_floor))
	}

	/// Determines the maximum value that the holder can splice out of the channel, accounting
	/// for the updated reserves after said splice. This maximum also makes sure the local
	/// commitment retains at least one output after the splice, which is particularly relevant
	/// for zero-reserve channels.
	fn get_next_splice_out_maximum(&self, funding: &FundingScope) -> Result<Amount, String> {
		// We are not interested in dust exposure
		let dust_exposure_limiting_feerate = None;

		// When reading the available balances, we take the remote's view of the pending
		// HTLCs, see `tx_builder` for further details
		let (remote_stats, _remote_htlcs) = self
			.context
			.get_next_remote_commitment_stats(
				funding,
				None, // htlc_candidate
				NextCommitmentView::ValidatingOwnUpdate,
				0,
				self.context.feerate_per_kw,
				false,
				dust_exposure_limiting_feerate,
			)
			.map_err(|()| "Balance exhausted on remote commitment")?;

		let next_splice_out_maximum_sat =
			remote_stats.available_balances.next_splice_out_maximum_sat;

		#[cfg(debug_assertions)]
		if !self.context.is_waiting_on_peer_pending_channel_update()
			&& !self.context.is_monitor_or_signer_pending_channel_update()
		{
			// After this max splice out, validation passes, accounting for the updated reserves
			self.validate_splice_contributions(
				SignedAmount::from_sat(-(next_splice_out_maximum_sat as i64)),
				SignedAmount::ZERO,
				funding.counterparty_funding_pubkey().clone(),
				funding.get_holder_pubkeys().clone(),
				// When the counterparty's contribution is non-negative, we don't validate
				// the post splice channel value against `min_funding_satoshis`
				0,
			)
			.unwrap();
			// Splice-out an additional satoshi, and validation fails!
			self.validate_splice_contributions(
				SignedAmount::from_sat(-((next_splice_out_maximum_sat + 1) as i64)),
				SignedAmount::ZERO,
				funding.counterparty_funding_pubkey().clone(),
				funding.get_holder_pubkeys().clone(),
				// When the counterparty's contribution is non-negative, we don't validate
				// the post splice channel value against `min_funding_satoshis`
				0,
			)
			.unwrap_err();
		}

		Ok(Amount::from_sat(next_splice_out_maximum_sat))
	}

	pub fn splice_locked<NS: NodeSigner, L: Logger>(
		&mut self, msg: &msgs::SpliceLocked, node_signer: &NS, chain_hash: ChainHash,
		user_config: &UserConfig, block_height: u32, logger: &L,
	) -> Result<Option<SpliceFundingPromotion>, ChannelError> {
		log_info!(logger, "Received splice_locked txid {} from our peer", msg.splice_txid,);

		let pending_splice = match self.pending_splice.as_mut() {
			Some(pending_splice) => pending_splice,
			None => {
				return Err(ChannelError::Ignore("Channel is not in pending splice".to_owned()));
			},
		};

		if !pending_splice
			.negotiated_candidates
			.iter()
			.any(|candidate| candidate.funding.get_funding_txid() == Some(msg.splice_txid))
		{
			let err = "unknown splice funding txid";
			return Err(ChannelError::close(err.to_string()));
		}
		pending_splice.received_funding_txid = Some(msg.splice_txid);

		if pending_splice.sent_funding_txid.is_none() {
			log_info!(
				logger,
				"Waiting for enough confirmations to send splice_locked txid {}",
				msg.splice_txid,
			);
			return Ok(None);
		}

		Ok(self.maybe_promote_splice_funding(
			node_signer,
			chain_hash,
			user_config,
			block_height,
			logger,
		))
	}

	/// Queues up an outbound HTLC to send by placing it in the holding cell. You should call
	/// [`Self::maybe_free_holding_cell_htlcs`] in order to actually generate and send the
	/// commitment update.
	pub fn queue_add_htlc<F: FeeEstimator, L: Logger>(
		&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32,
		source: HTLCSource, onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>,
		blinding_point: Option<PublicKey>, accountable: bool,
		fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<(), (LocalHTLCFailureReason, String)> {
		self.send_htlc(
			amount_msat,
			payment_hash,
			cltv_expiry,
			source,
			onion_routing_packet,
			true,
			skimmed_fee_msat,
			blinding_point,
			// This method is only called for forwarded HTLCs, which are never held at the next hop
			false,
			accountable,
			fee_estimator,
			logger,
		)
		.map(|can_add_htlc| assert!(!can_add_htlc, "We forced holding cell?"))
		.map_err(|err| {
			debug_assert!(err.0.is_temporary(), "Queuing HTLC should return temporary error");
			err
		})
	}

	/// Adds a pending outbound HTLC to this channel, note that you probably want
	/// [`Self::send_htlc_and_commit`] instead cause you'll want both messages at once.
	///
	/// This returns a boolean indicating whether we are in a state where we can add HTLCs on the wire.
	/// Reasons we may not be able to add HTLCs on the wire include:
	///
	/// * In cases where we're waiting on the remote peer to send us a revoke_and_ack, we
	///   wouldn't be able to determine what they actually ACK'ed if we have two sets of updates
	///   awaiting ACK.
	/// * In cases where we're marked MonitorUpdateInProgress, we cannot commit to a new state as
	///   we may not yet have sent the previous commitment update messages and will need to
	///   regenerate them.
	///
	/// You MUST call [`Self::send_commitment_no_state_update`] prior to calling any other methods
	/// on this [`FundedChannel`] if `force_holding_cell` is false.
	///
	/// `Err`'s will always be temporary channel failures.
	fn send_htlc<F: FeeEstimator, L: Logger>(
		&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32,
		source: HTLCSource, onion_routing_packet: msgs::OnionPacket, mut force_holding_cell: bool,
		skimmed_fee_msat: Option<u64>, blinding_point: Option<PublicKey>, hold_htlc: bool,
		accountable: bool, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
	) -> Result<bool, (LocalHTLCFailureReason, String)> {
		if !matches!(self.context.channel_state, ChannelState::ChannelReady(_))
			|| self.context.channel_state.is_local_shutdown_sent()
			|| self.context.channel_state.is_remote_shutdown_sent()
		{
			return Err((LocalHTLCFailureReason::ChannelNotReady,
				"Cannot send HTLC until channel is fully established and we haven't started shutting down".to_owned()));
		}

		if amount_msat == 0 {
			return Err((LocalHTLCFailureReason::ZeroAmount, "Cannot send 0-msat HTLC".to_owned()));
		}

		let available_balances = self.get_available_balances(fee_estimator).map_err(|()| {
			(
				LocalHTLCFailureReason::ChannelBalanceOverdrawn,
				"Channel balance overdrawn".to_owned(),
			)
		})?;
		if amount_msat < available_balances.next_outbound_htlc_minimum_msat {
			return Err((
				LocalHTLCFailureReason::HTLCMinimum,
				format!(
					"Cannot send less than our next-HTLC minimum - {} msat",
					available_balances.next_outbound_htlc_minimum_msat
				),
			));
		}

		if amount_msat > available_balances.next_outbound_htlc_limit_msat {
			return Err((
				LocalHTLCFailureReason::HTLCMaximum,
				format!(
					"Cannot send more than our next-HTLC maximum - {} msat",
					available_balances.next_outbound_htlc_limit_msat
				),
			));
		}

		if self.context.channel_state.is_peer_disconnected() {
			// Note that this should never really happen, if we're !is_live() on receipt of an
			// incoming HTLC for relay will result in us rejecting the HTLC and we won't allow
			// the user to send directly into a !is_live() channel. However, if we
			// disconnected during the time the previous hop was doing the commitment dance we may
			// end up getting here after the forwarding delay. In any case, returning an
			// IgnoreError will get ChannelManager to do the right thing and fail backwards now.
			return Err((
				LocalHTLCFailureReason::PeerOffline,
				"Cannot send an HTLC while disconnected from channel counterparty".to_owned(),
			));
		}

		let need_holding_cell = !self.context.channel_state.can_generate_new_commitment();
		log_debug!(
			logger,
			"Pushing new outbound HTLC with hash {} for {} msat {}",
			payment_hash,
			amount_msat,
			if force_holding_cell {
				"into holding cell"
			} else if need_holding_cell {
				"into holding cell as we're awaiting an RAA or monitor"
			} else {
				"to peer"
			}
		);

		if need_holding_cell {
			force_holding_cell = true;
		}

		// Now update local state:
		if force_holding_cell {
			self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
				amount_msat,
				payment_hash,
				cltv_expiry,
				source,
				onion_routing_packet,
				skimmed_fee_msat,
				blinding_point,
				hold_htlc: hold_htlc.then(|| ()),
				accountable,
			});
			return Ok(false);
		}

		// Record the approximate time when the HTLC is sent to the peer. This timestamp is later used to calculate the
		// htlc hold time for reporting back to the sender. There is some freedom to report a time including or
		// excluding our own processing time. What we choose here doesn't matter all that much, because it will probably
		// just shift sender-applied penalties between our incoming and outgoing side. So we choose measuring points
		// that are simple to implement, and we do it on the outgoing side because then the failure message that encodes
		// the hold time still needs to be built in channel manager.
		let send_timestamp = duration_since_epoch();
		self.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: self.context.next_holder_htlc_id,
			amount_msat,
			payment_hash,
			cltv_expiry,
			state: OutboundHTLCState::LocalAnnounced(Box::new(onion_routing_packet)),
			source,
			blinding_point,
			skimmed_fee_msat,
			send_timestamp,
			hold_htlc: hold_htlc.then(|| ()),
			accountable,
		});
		self.context.next_holder_htlc_id += 1;

		Ok(true)
	}

	/// Gets the available balances, see [`AvailableBalances`]'s fields for more info.
	///
	/// Returns `Err` if some party cannot currently pay for the HTLCs outbound from said party, and the anchors and
	/// transaction fee if they are the funder.
	pub(super) fn get_available_balances<F: FeeEstimator>(
		&self, fee_estimator: &LowerBoundedFeeEstimator<F>,
	) -> Result<AvailableBalances, ()> {
		let init = self.context.get_available_balances_for_scope(&self.funding, fee_estimator)?;
		self.pending_funding().try_fold(init, |acc, funding| {
			let e = self.context.get_available_balances_for_scope(funding, fee_estimator)?;
			Ok(AvailableBalances {
				inbound_capacity_msat: acc.inbound_capacity_msat.min(e.inbound_capacity_msat),
				outbound_capacity_msat: acc.outbound_capacity_msat.min(e.outbound_capacity_msat),
				next_outbound_htlc_limit_msat: acc
					.next_outbound_htlc_limit_msat
					.min(e.next_outbound_htlc_limit_msat),
				next_outbound_htlc_minimum_msat: acc
					.next_outbound_htlc_minimum_msat
					.max(e.next_outbound_htlc_minimum_msat),
				dust_exposure_msat: acc.dust_exposure_msat.max(e.dust_exposure_msat),
				next_splice_out_maximum_sat: acc
					.next_splice_out_maximum_sat
					.min(e.next_splice_out_maximum_sat),
			})
		})
	}

	fn build_commitment_no_status_check<L: Logger>(&mut self, logger: &L) -> ChannelMonitorUpdate {
		log_trace!(logger, "Updating HTLC state for a newly-sent commitment_signed...");
		// We can upgrade the status of some HTLCs that are waiting on a commitment, even if we
		// fail to generate this, we still are at least at a position where upgrading their status
		// is acceptable.
		for htlc in self.context.pending_inbound_htlcs.iter_mut() {
			let new_state =
				if let &InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref forward_info) =
					&htlc.state
				{
					Some(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(forward_info.clone()))
				} else {
					None
				};
			if let Some(state) = new_state {
				log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce {} to AwaitingAnnouncedRemoteRevoke", &htlc.payment_hash);
				htlc.state = state;
			}
		}
		for htlc in self.context.pending_outbound_htlcs.iter_mut() {
			if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) =
				&mut htlc.state
			{
				log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", &htlc.payment_hash);
				// Swap against a dummy variant to avoid a potentially expensive clone of `OutboundHTLCOutcome::Failure(HTLCFailReason)`
				let mut reason = OutboundHTLCOutcome::Success {
					preimage: PaymentPreimage([0u8; 32]),
					attribution_data: None,
				};
				mem::swap(outcome, &mut reason);
				htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
			}
		}
		if let Some((feerate, update_state)) = self.context.pending_update_fee {
			if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {
				debug_assert!(!self.funding.is_outbound());
				log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
				self.context.feerate_per_kw = feerate;
				self.context.pending_update_fee = None;
			}
		}
		self.context.resend_order = RAACommitmentOrder::RevokeAndACKFirst;

		let update = if self.negotiated_candidates().is_empty() {
			let (htlcs_ref, counterparty_commitment_tx) =
				self.build_commitment_no_state_update(&self.funding, logger);
			let htlc_outputs = htlcs_ref
				.into_iter()
				.map(|(htlc, htlc_source)| {
					(htlc, htlc_source.map(|source_ref| Box::new(source_ref.clone())))
				})
				.collect();

			// Soon, we will switch this to `LatestCounterpartyCommitment`,
			// and provide the full commit tx instead of the information needed to rebuild it.
			ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
				commitment_txid: counterparty_commitment_tx.trust().txid(),
				htlc_outputs,
				commitment_number: self.context.counterparty_next_commitment_transaction_number,
				their_per_commitment_point: self
					.context
					.counterparty_next_commitment_point
					.unwrap(),
				feerate_per_kw: Some(counterparty_commitment_tx.negotiated_feerate_per_kw()),
				to_broadcaster_value_sat: Some(
					counterparty_commitment_tx.to_broadcaster_value_sat(),
				),
				to_countersignatory_value_sat: Some(
					counterparty_commitment_tx.to_countersignatory_value_sat(),
				),
			}
		} else {
			let mut htlc_data = None;
			let commitment_txs = core::iter::once(&self.funding)
				.chain(self.pending_funding())
				.map(|funding| {
					let (htlcs_ref, counterparty_commitment_tx) =
						self.build_commitment_no_state_update(funding, logger);
					if htlc_data.is_none() {
						let nondust_htlc_sources = htlcs_ref
							.iter()
							// We check !offered as this is the HTLC from the counterparty's point of view.
							.filter(|(htlc, _)| {
								!htlc.offered && htlc.transaction_output_index.is_some()
							})
							.map(|(_, source)| {
								source.expect("Outbound HTLC must have a source").clone()
							})
							.collect();
						let dust_htlcs = htlcs_ref
							.into_iter()
							.filter(|(htlc, _)| htlc.transaction_output_index.is_none())
							.map(|(htlc, source)| (htlc, source.cloned()))
							.collect();
						htlc_data = Some(CommitmentHTLCData { nondust_htlc_sources, dust_htlcs });
					}
					counterparty_commitment_tx
				})
				.collect();
			let htlc_data = htlc_data.unwrap();
			ChannelMonitorUpdateStep::LatestCounterpartyCommitment { commitment_txs, htlc_data }
		};

		if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent {
			self.context.announcement_sigs_state = AnnouncementSigsState::Committed;
		}

		self.context.latest_monitor_update_id += 1;
		let monitor_update = ChannelMonitorUpdate {
			update_id: self.context.latest_monitor_update_id,
			updates: vec![update],
			channel_id: Some(self.context.channel_id()),
		};
		self.context.channel_state.set_awaiting_remote_revoke();
		monitor_update
	}

	#[rustfmt::skip]
	pub(super) fn build_commitment_no_state_update<L: Logger>(
		&self, funding: &FundingScope, logger: &L,
	) -> (Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>, CommitmentTransaction) {
		let commitment_data = self.context.build_commitment_transaction(
			funding, self.context.counterparty_next_commitment_transaction_number,
			&self.context.counterparty_next_commitment_point.unwrap(), false, true, logger,
		);
		let counterparty_commitment_tx = commitment_data.tx;

		(commitment_data.htlcs_included, counterparty_commitment_tx)
	}

	/// Only fails in case of signer rejection. Used for channel_reestablish commitment_signed
	/// generation when we shouldn't change HTLC/channel state.
	fn send_commitment_no_state_update<L: Logger>(
		&self, logger: &L,
	) -> Result<Vec<msgs::CommitmentSigned>, ChannelError> {
		core::iter::once(&self.funding)
			.chain(self.pending_funding())
			.map(|funding| self.send_commitment_no_state_update_for_funding(funding, logger))
			.collect::<Result<Vec<_>, ChannelError>>()
	}

	#[rustfmt::skip]
	fn send_commitment_no_state_update_for_funding<L: Logger>(
		&self, funding: &FundingScope, logger: &L,
	) -> Result<msgs::CommitmentSigned, ChannelError> {
		// Get the fee tests from `build_commitment_no_state_update`
		#[cfg(any(test, fuzzing))]
		self.build_commitment_no_state_update(funding, logger);

		let commitment_data = self.context.build_commitment_transaction(
			funding, self.context.counterparty_next_commitment_transaction_number,
			&self.context.counterparty_next_commitment_point.unwrap(), false, true, logger,
		);
		let counterparty_commitment_tx = commitment_data.tx;

		let (signature, htlc_signatures);

		{
			let res = self.context.holder_signer
				.sign_counterparty_commitment(
					&funding.channel_transaction_parameters,
					&counterparty_commitment_tx,
					commitment_data.inbound_htlc_preimages,
					commitment_data.outbound_htlc_preimages,
					&self.context.secp_ctx,
				)
				.map_err(|_| ChannelError::Ignore("Failed to get signatures for new commitment_signed".to_owned()))?;
			signature = res.0;
			htlc_signatures = res.1;

			let trusted_tx = counterparty_commitment_tx.trust();
			log_trace!(logger, "Signed remote commitment tx {} (txid {}) with redeemscript {} -> {}",
				encode::serialize_hex(&trusted_tx.built_transaction().transaction),
				&trusted_tx.txid(), encode::serialize_hex(&funding.get_funding_redeemscript()),
				log_bytes!(signature.serialize_compact()[..]));

			let counterparty_keys = trusted_tx.keys();
			debug_assert_eq!(htlc_signatures.len(), trusted_tx.nondust_htlcs().len());
			for (ref htlc_sig, ref htlc) in htlc_signatures.iter().zip(trusted_tx.nondust_htlcs()) {
				log_trace!(logger, "Signed remote HTLC tx {} with redeemscript {} with pubkey {} -> {}",
					encode::serialize_hex(&chan_utils::build_htlc_transaction(&trusted_tx.txid(), trusted_tx.negotiated_feerate_per_kw(), funding.get_holder_selected_contest_delay(), htlc, funding.get_channel_type(), &counterparty_keys.broadcaster_delayed_payment_key, &counterparty_keys.revocation_key)),
					encode::serialize_hex(&chan_utils::get_htlc_redeemscript(&htlc, funding.get_channel_type(), &counterparty_keys)),
					log_bytes!(counterparty_keys.broadcaster_htlc_key.to_public_key().serialize()),
					log_bytes!(htlc_sig.serialize_compact()[..]));
			}
		}

		Ok(msgs::CommitmentSigned {
			channel_id: self.context.channel_id,
			signature,
			htlc_signatures,
			funding_txid: funding.get_funding_txo().map(|funding_txo| funding_txo.txid),
		})
	}

	/// Adds a pending outbound HTLC to this channel, and builds a new remote commitment
	/// transaction and generates the corresponding [`ChannelMonitorUpdate`] in one go.
	///
	/// Shorthand for calling [`Self::send_htlc`] followed by a commitment update, see docs on
	/// [`Self::send_htlc`] and [`Self::build_commitment_no_state_update`] for more info.
	pub fn send_htlc_and_commit<F: FeeEstimator, L: Logger>(
		&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32,
		source: HTLCSource, onion_routing_packet: msgs::OnionPacket, skimmed_fee_msat: Option<u64>,
		hold_htlc: bool, accountable: bool, fee_estimator: &LowerBoundedFeeEstimator<F>,
		logger: &L,
	) -> Result<Option<ChannelMonitorUpdate>, ChannelError> {
		let send_res = self.send_htlc(
			amount_msat,
			payment_hash,
			cltv_expiry,
			source,
			onion_routing_packet,
			false,
			skimmed_fee_msat,
			None,
			hold_htlc,
			accountable,
			fee_estimator,
			logger,
		);
		// All [`LocalHTLCFailureReason`] errors are temporary, so they are [`ChannelError::Ignore`].
		let can_add_htlc = send_res.map_err(|(_, msg)| ChannelError::Ignore(msg))?;
		if can_add_htlc {
			let monitor_update = self.build_commitment_no_status_check(logger);
			self.monitor_updating_paused(
				false,
				true,
				false,
				Vec::new(),
				Vec::new(),
				Vec::new(),
				logger,
			);
			Ok(self.push_ret_blockable_mon_update(monitor_update))
		} else {
			Ok(None)
		}
	}

	/// Applies the `ChannelUpdate` and returns a boolean indicating whether a change actually
	/// happened.
	#[rustfmt::skip]
	pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<bool, ChannelError> {
		let new_forwarding_info = Some(CounterpartyForwardingInfo {
			fee_base_msat: msg.contents.fee_base_msat,
			fee_proportional_millionths: msg.contents.fee_proportional_millionths,
			cltv_expiry_delta: msg.contents.cltv_expiry_delta
		});
		let did_change = self.context.counterparty_forwarding_info != new_forwarding_info;
		if did_change {
			self.context.counterparty_forwarding_info = new_forwarding_info;
		}

		Ok(did_change)
	}

	/// Begins the shutdown process, getting a message for the remote peer and returning all
	/// holding cell HTLCs for payment failure.
	pub fn get_shutdown<L: Logger>(
		&mut self, signer_provider: &SP, their_features: &InitFeatures,
		target_feerate_sats_per_kw: Option<u32>, override_shutdown_script: Option<ShutdownScript>,
		logger: &L,
	) -> Result<
		(
			msgs::Shutdown,
			Option<ChannelMonitorUpdate>,
			Vec<(HTLCSource, PaymentHash)>,
			Option<SpliceFundingFailed>,
		),
		APIError,
	> {
		let logger = WithChannelContext::from(logger, &self.context, None);

		if self.context.channel_state.is_local_stfu_sent()
			|| self.context.channel_state.is_remote_stfu_sent()
			|| self.context.channel_state.is_quiescent()
		{
			return Err(APIError::APIMisuseError {
				err: "Cannot begin shutdown while quiescent".to_owned(),
			});
		}
		for htlc in self.context.pending_outbound_htlcs.iter() {
			if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
				return Err(APIError::APIMisuseError {
					err: "Cannot begin shutdown with pending HTLCs. Process pending events first"
						.to_owned(),
				});
			}
		}
		if self.context.channel_state.is_local_shutdown_sent() {
			return Err(APIError::APIMisuseError {
				err: "Shutdown already in progress".to_owned(),
			});
		} else if self.context.channel_state.is_remote_shutdown_sent() {
			return Err(APIError::ChannelUnavailable {
				err: "Shutdown already in progress by remote".to_owned(),
			});
		}
		if self.context.shutdown_scriptpubkey.is_some() && override_shutdown_script.is_some() {
			return Err(APIError::APIMisuseError {
				err: "Cannot override shutdown script for a channel with one already set"
					.to_owned(),
			});
		}
		assert!(!matches!(self.context.channel_state, ChannelState::ShutdownComplete));
		if self.context.channel_state.is_peer_disconnected()
			|| self.context.channel_state.is_monitor_update_in_progress()
		{
			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()});
		}

		let update_shutdown_script = match self.context.shutdown_scriptpubkey {
			Some(_) => false,
			None => {
				// use override shutdown script if provided
				let shutdown_scriptpubkey = match override_shutdown_script {
					Some(script) => script,
					None => {
						// otherwise, use the shutdown scriptpubkey provided by the signer
						match signer_provider.get_shutdown_scriptpubkey() {
							Ok(scriptpubkey) => scriptpubkey,
							Err(_) => {
								return Err(APIError::ChannelUnavailable {
									err: "Failed to get shutdown scriptpubkey".to_owned(),
								})
							},
						}
					},
				};
				if !shutdown_scriptpubkey.is_compatible(their_features) {
					return Err(APIError::IncompatibleShutdownScript {
						script: shutdown_scriptpubkey.clone(),
					});
				}
				self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
				true
			},
		};

		// From here on out, we may not fail!
		self.context.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
		self.context.channel_state.set_local_shutdown_sent();
		self.context.local_initiated_shutdown = Some(());
		self.context.update_time_counter += 1;

		let monitor_update = if update_shutdown_script {
			self.context.latest_monitor_update_id += 1;
			let monitor_update = ChannelMonitorUpdate {
				update_id: self.context.latest_monitor_update_id,
				updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
					scriptpubkey: self.get_closing_scriptpubkey(),
				}],
				channel_id: Some(self.context.channel_id()),
			};
			self.monitor_updating_paused(
				false,
				false,
				false,
				Vec::new(),
				Vec::new(),
				Vec::new(),
				&&logger,
			);
			self.push_ret_blockable_mon_update(monitor_update)
		} else {
			None
		};
		let shutdown = msgs::Shutdown {
			channel_id: self.context.channel_id,
			scriptpubkey: self.get_closing_scriptpubkey(),
		};

		// Go ahead and drop holding cell updates as we'd rather fail payments than wait to send
		// our shutdown until we've committed all of the pending changes.
		self.context.holding_cell_update_fee = None;
		let mut dropped_outbound_htlcs =
			Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
		self.context.holding_cell_htlc_updates.retain(|htlc_update| match htlc_update {
			&HTLCUpdateAwaitingACK::AddHTLC { ref payment_hash, ref source, .. } => {
				dropped_outbound_htlcs.push((source.clone(), payment_hash.clone()));
				false
			},
			_ => true,
		});

		debug_assert!(
			!self.is_shutdown() || monitor_update.is_none(),
			"we can't both complete shutdown and return a monitor update"
		);

		let splice_funding_failed = self.abandon_quiescent_action();

		Ok((shutdown, monitor_update, dropped_outbound_htlcs, splice_funding_failed))
	}

	// Miscellaneous utilities

	#[rustfmt::skip]
	pub fn inflight_htlc_sources(&self) -> impl Iterator<Item=(&HTLCSource, &PaymentHash)> {
		self.context.holding_cell_htlc_updates.iter()
			.flat_map(|htlc_update| {
				match htlc_update {
					HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. }
						=> Some((source, payment_hash)),
					_ => None,
				}
			})
			.chain(self.context.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
	}

	pub fn get_announced_htlc_max_msat(&self) -> u64 {
		return cmp::min(
			// Upper bound by capacity. We make it a bit less than full capacity to prevent attempts
			// to use full capacity. This is an effort to reduce routing failures, because in many cases
			// channel might have been used to route very small values (either by honest users or as DoS).
			self.funding.get_value_satoshis() * 1000 * 9 / 10,
			self.context.counterparty_max_htlc_value_in_flight_msat,
		);
	}

	#[rustfmt::skip]
	pub fn propose_quiescence<L: Logger>(
		&mut self, logger: &L, action: QuiescentAction,
	) -> Result<Option<msgs::Stfu>, QuiescentError> {
		log_debug!(logger, "Attempting to initiate quiescence");

		if !self.context.is_usable() {
			debug_assert!(
				self.context.channel_state.is_local_shutdown_sent()
					|| self.context.channel_state.is_remote_shutdown_sent(),
				"splice_channel should have prevented reaching propose_quiescence on a non-ready channel"
			);
			log_debug!(logger, "Channel is not in a usable state to propose quiescence");
			return Err(match action {
				QuiescentAction::Splice { contribution, .. } => QuiescentError::FailSplice(
					SpliceFundingFailed::from_contribution(contribution),
					NegotiationFailureReason::ChannelClosing,
				),
				#[cfg(any(test, fuzzing, feature = "_test_utils"))]
				QuiescentAction::DoNothing => QuiescentError::DoNothing,
			});
		}

		if self.quiescent_action.is_some() {
			debug_assert!(
				false,
				"callers must not invoke propose_quiescence with {:?} while quiescent_action is set",
				action,
			);
			log_debug!(
				logger,
				"Channel already has a pending quiescent action and cannot start another",
			);
			return Err(match action {
				#[cfg(any(test, fuzzing, feature = "_test_utils"))]
				QuiescentAction::DoNothing => QuiescentError::DoNothing,
				QuiescentAction::Splice { contribution, .. } => QuiescentError::FailSplice(
					SpliceFundingFailed::from_contribution(contribution),
					NegotiationFailureReason::Unknown,
				),
			});
		}

		self.quiescent_action = Some(action);
		if self.context.channel_state.is_quiescent() {
			log_debug!(logger, "Channel is already quiescent");
			return Ok(None);
		}

		Ok(self.try_send_stfu(false, logger))
	}

	#[rustfmt::skip]
	pub fn stfu<L: Logger>(
		&mut self, msg: &msgs::Stfu, logger: &L
	) -> Result<Option<StfuResponse>, (ChannelError, QuiescentError)> {
		if self.context.channel_state.is_quiescent() {
			return Err((ChannelError::Warn("Channel is already quiescent".to_owned()), QuiescentError::DoNothing));
		}
		if self.context.channel_state.is_remote_stfu_sent() {
			return Err((ChannelError::Warn(
				"Peer sent `stfu` when they already sent it and we've yet to become quiescent".to_owned()
			), QuiescentError::DoNothing));
		}

		if !self.context.is_live() {
			return Err((ChannelError::Warn(
				"Peer sent `stfu` when we were not in a live state".to_owned()
			), QuiescentError::DoNothing));
		}

		if !self.context.channel_state.is_local_stfu_sent() {
			if !msg.initiator {
				return Err((ChannelError::WarnAndDisconnect(
					"Peer sent unexpected `stfu` without signaling as initiator".to_owned()
				), QuiescentError::DoNothing));
			}

			// We don't check `is_waiting_on_peer_pending_channel_update` prior to setting the flag
			// because it considers pending updates from either node. This means we may accept a
			// counterparty `stfu` while they had pending updates, but that's fine as we won't send
			// ours until _all_ pending updates complete, allowing the channel to become quiescent
			// then.
			self.context.channel_state.set_remote_stfu_sent();

			log_debug!(logger, "Received counterparty stfu proposing quiescence");
			return Ok(self.try_send_stfu(false, logger).map(|stfu| StfuResponse::Stfu(stfu)))
		}

		// We already sent `stfu` and are now processing theirs. It may be in response to ours, or
		// we happened to both send `stfu` at the same time and a tie-break is needed.
		let is_holder_quiescence_initiator = !msg.initiator || self.funding.is_outbound();

		// We were expecting to receive `stfu` because we already sent ours.
		self.mark_response_received();

		if self.context.is_waiting_on_peer_pending_channel_update()
			|| self.context.signer_pending_revoke_and_ack
			|| self.context.signer_pending_commitment_update
		{
			// Since we've already sent `stfu`, it should not be possible for one of our updates to
			// be pending, so anything pending currently must be from a counterparty update. We may
			// have a monitor update pending if we've processed a message from the counterparty, but
			// we don't consider this when becoming quiescent since the states are not mutually
			// exclusive.
			return Err((ChannelError::WarnAndDisconnect(
				"Received counterparty stfu while having pending counterparty updates".to_owned()
			), QuiescentError::DoNothing));
		}

		self.context.channel_state.clear_local_stfu_sent();
		self.context.channel_state.set_quiescent();

		log_debug!(
			logger,
			"Received counterparty stfu, channel is now quiescent and we are{} the initiator",
			if !is_holder_quiescence_initiator { " not" } else { "" }
		);

		if is_holder_quiescence_initiator {
			match self.quiescent_action.take() {
				None => {
					// We may have lost a `QuiescentAction::Splice` if we had already started the
					// quiescence handshake for it, but an existing pending splice became locked,
					// invalidating the queued splice.
					return Err((ChannelError::WarnAndDisconnect(
						"Quiescence no longer needed".to_owned()
					), QuiescentError::DoNothing));
				},
				Some(QuiescentAction::Splice { contribution, locktime }) => {
					if self.pending_splice.is_some() {
						if !self.queued_contribution_can_rbf(&contribution) {
							let msg = "Waiting for splice to lock before potentially proceeding with queued contribution".into();
							self.quiescent_action = Some(QuiescentAction::Splice { contribution, locktime });
							return Err((
								ChannelError::WarnAndDisconnect(msg),
								QuiescentError::DoNothing,
							));
						}
					}

					// Re-validate the contribution now that we're quiescent and
					// balances are stable. Outbound HTLCs may have been sent between
					// funding_contributed and quiescence, reducing the holder's
					// balance. If invalid, disconnect and return the contribution so
					// the user can reclaim their inputs.
					let our_funding_contribution = contribution.net_value();
					let unsigned_contribution = our_funding_contribution.unsigned_abs();
					if let Err(e) = self.get_next_splice_out_maximum(&self.funding)
						.and_then(|splice_max| splice_max
							.to_sat()
							.checked_add_signed(our_funding_contribution.to_sat())
							.ok_or(format!("Our splice-out value of {unsigned_contribution} is greater than the maximum {splice_max}"))
						)
					{
						let failed = SpliceFundingFailed::from_contribution(contribution);
						return Err((
							ChannelError::WarnAndDisconnect(format!(
								"Channel {} contribution no longer valid at quiescence: {}",
								self.context.channel_id(),
								e,
							)),
							QuiescentError::FailSplice(
								failed,
								NegotiationFailureReason::ContributionInvalid,
							),
						));
					}

					let prev_funding_input = self.funding.to_splice_funding_input();
					let our_funding_contribution = contribution.net_value();
					let funding_feerate_per_kw = contribution.feerate().to_sat_per_kwu() as u32;
					let (our_funding_inputs, our_funding_outputs) = contribution.clone().into_tx_parts();
					let context = FundingNegotiationContext {
						is_initiator: true,
						our_funding_contribution,
						funding_tx_locktime: locktime,
						funding_feerate_sat_per_1000_weight: funding_feerate_per_kw,
						shared_funding_input: Some(prev_funding_input),
						our_funding_inputs,
						our_funding_outputs,
					};

					if self.pending_splice.is_some() {
						let tx_init_rbf = self.send_tx_init_rbf(context, contribution);
						return Ok(Some(StfuResponse::TxInitRbf(tx_init_rbf)));
					}
					let splice_init = self.send_splice_init(context, contribution);
					debug_assert!(self.pending_splice.is_some());
					return Ok(Some(StfuResponse::SpliceInit(splice_init)));
				},
				#[cfg(any(test, fuzzing, feature = "_test_utils"))]
				Some(QuiescentAction::DoNothing) => {
					// In quiescence test we want to just hang out here, letting the test manually
					// leave quiescence.
				},
			}
		}

		Ok(None)
	}

	pub fn try_send_stfu<L: Logger>(&mut self, is_retry: bool, logger: &L) -> Option<msgs::Stfu> {
		// We must never see both stfu flags set, we always set the quiescent flag instead.
		debug_assert!(
			!(self.context.channel_state.is_local_stfu_sent()
				&& self.context.channel_state.is_remote_stfu_sent())
		);

		// We only need to send `stfu` when we're awaiting quiescence and haven't sent it yet, or
		// in response to a counterparty one.
		if self.quiescent_action.is_none() && !self.context.channel_state.is_remote_stfu_sent() {
			return None;
		}
		if self.context.channel_state.is_local_stfu_sent()
			|| self.context.channel_state.is_quiescent()
		{
			return None;
		}

		// We retry sending `stfu` every time pending messages are polled, so only log why we're
		// unable to on the first attempt, lest we spam the log.
		if !self.context.is_live() {
			if !is_retry {
				log_debug!(logger, "Waiting for peer reconnection to send stfu");
			}
			return None;
		}

		if self.context.is_waiting_on_peer_pending_channel_update()
			|| self.context.is_monitor_or_signer_pending_channel_update()
		{
			if !is_retry {
				log_debug!(
					logger,
					"Waiting for state machine pending changes to complete before sending stfu"
				);
			}
			return None;
		}

		let initiator = if self.context.channel_state.is_remote_stfu_sent() {
			// Since we may have also attempted to initiate quiescence but the counterparty
			// initiated first, we'll retry after we're no longer quiescent.
			self.context.channel_state.clear_remote_stfu_sent();
			self.context.channel_state.set_quiescent();
			false
		} else if let Some(action) = self.quiescent_action.as_ref() {
			#[allow(irrefutable_let_patterns)]
			if let QuiescentAction::Splice { contribution, .. } = action {
				if self.pending_splice.is_some() {
					if !self.queued_contribution_can_rbf(contribution) {
						if !is_retry {
							log_debug!(
								logger,
								"Waiting for splice to lock before potentially proceeding with queued contribution"
							);
						}
						return None;
					}
				}
			}

			log_debug!(logger, "Sending stfu as quiescence initiator");
			self.context.channel_state.set_local_stfu_sent();
			true
		} else {
			debug_assert!(
				false,
				"Either we have a pending quiescent action or need to respond to the counterparty"
			);
			false
		};

		Some(msgs::Stfu { channel_id: self.context.channel_id, initiator })
	}

	pub fn exit_quiescence(&mut self) -> bool {
		// Make sure we either finished the quiescence handshake and are quiescent, or we never
		// attempted to initiate quiescence at all.
		debug_assert!(!self.context.channel_state.is_local_stfu_sent());
		debug_assert!(!self.context.channel_state.is_remote_stfu_sent());

		self.mark_response_received();
		let was_quiescent = self.context.channel_state.is_quiescent();
		self.context.channel_state.clear_quiescent();
		was_quiescent
	}

	fn quiescent_negotiation_err(&mut self, err: ChannelError) -> InteractiveTxMsgError {
		if matches!(err, ChannelError::Abort(_)) {
			debug_assert!(self.context.channel_state.is_quiescent());
			self.exit_quiescence();
		}
		InteractiveTxMsgError::new(err, None)
	}

	pub fn remove_legacy_scids_before_block(&mut self, height: u32) -> alloc::vec::Drain<'_, u64> {
		let end = self
			.funding
			.get_short_channel_id()
			.map(|current_scid| {
				let historical_scids = &self.context.historical_scids;
				historical_scids
					.iter()
					.zip(historical_scids.iter().skip(1).chain(core::iter::once(&current_scid)))
					.filter(|(_, next_scid)| {
						let funding_height = block_from_scid(**next_scid);
						let drop_scid =
							funding_height + CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY - 1 <= height;
						drop_scid
					})
					.count()
			})
			.unwrap_or(0);

		// Drains the oldest historical SCIDs until reaching one without
		// CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY confirmations.
		self.context.historical_scids.drain(0..end)
	}
}

/// A not-yet-funded outbound (from holder) channel using V1 channel establishment.
pub(super) struct OutboundV1Channel<SP: SignerProvider> {
	pub funding: FundingScope,
	pub context: ChannelContext<SP>,
	pub unfunded_context: UnfundedChannelContext,
	/// We tried to send an `open_channel` message but our commitment point wasn't ready.
	/// This flag tells us we need to send it when we are retried once the
	/// commitment point is ready.
	pub signer_pending_open_channel: bool,
}

impl<SP: SignerProvider> OutboundV1Channel<SP> {
	pub fn abandon_unfunded_chan(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
		self.context.force_shutdown(&self.funding, closure_reason)
	}

	#[allow(dead_code)] // TODO(dual_funding): Remove once opending V2 channels is enabled.
	pub fn new<ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
		counterparty_node_id: PublicKey, their_features: &InitFeatures,
		channel_value_satoshis: u64, push_msat: u64, user_id: u128, config: &UserConfig,
		current_chain_height: u32, outbound_scid_alias: u64,
		temporary_channel_id: Option<ChannelId>, logger: L,
		trusted_channel_features: Option<TrustedChannelFeatures>,
	) -> Result<OutboundV1Channel<SP>, APIError> {
		// At this point, we do not know what `dust_limit_satoshis` the counterparty will want for themselves,
		// so we set the channel reserve with no regard for their dust limit, and fail the channel if they want
		// a dust limit higher than our selected reserve.
		let their_dust_limit_satoshis = 0;
		let is_0reserve = trusted_channel_features.is_some_and(|f| f.is_0reserve());
		let holder_selected_channel_reserve_satoshis =
			get_holder_selected_channel_reserve_satoshis(
				channel_value_satoshis,
				their_dust_limit_satoshis,
				config,
				is_0reserve,
			)
			.map_err(|()| APIError::APIMisuseError {
				err: format!(
					"The channel value {channel_value_satoshis} is smaller than \
					{MIN_THEIR_CHAN_RESERVE_SATOSHIS}"
				),
			})?;
		if holder_selected_channel_reserve_satoshis < MIN_CHAN_DUST_LIMIT_SATOSHIS && !is_0reserve {
			// Protocol level safety check in place, although it should never happen because
			// of `MIN_THEIR_CHAN_RESERVE_SATOSHIS` and `MIN_CHANNEL_VALUE_SATOSHIS`
			return Err(APIError::APIMisuseError {
				err: format!(
					"Holder selected channel reserve below implementation limit dust_limit_satoshis {holder_selected_channel_reserve_satoshis}"
				),
			});
		}

		let channel_keys_id = signer_provider.generate_channel_keys_id(false, user_id);
		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);

		let temporary_channel_id_fn =
			temporary_channel_id.map(|id| move |_: &ChannelPublicKeys| id);

		let (funding, context) = ChannelContext::new_for_outbound_channel(
			fee_estimator,
			entropy_source,
			signer_provider,
			counterparty_node_id,
			their_features,
			channel_value_satoshis,
			push_msat,
			user_id,
			config,
			current_chain_height,
			outbound_scid_alias,
			temporary_channel_id_fn,
			holder_selected_channel_reserve_satoshis,
			channel_keys_id,
			holder_signer,
			logger,
		)?;
		let unfunded_context = UnfundedChannelContext {
			unfunded_channel_age_ticks: 0,
			holder_commitment_point: HolderCommitmentPoint::new(
				&context.holder_signer,
				&context.secp_ctx,
			),
		};

		// We initialize `signer_pending_open_channel` to false, and leave setting the flag
		// for when we try to generate the open_channel message.
		let chan = Self { funding, context, unfunded_context, signer_pending_open_channel: false };
		Ok(chan)
	}

	/// Only allowed after [`FundingScope::channel_transaction_parameters`] is set.
	#[rustfmt::skip]
	fn get_funding_created_msg<L: Logger>(&mut self, logger: &L) -> Option<msgs::FundingCreated> {
		let commitment_data = self.context.build_commitment_transaction(&self.funding,
			self.context.counterparty_next_commitment_transaction_number,
			&self.context.counterparty_next_commitment_point.unwrap(), false, false, logger);
		let counterparty_initial_commitment_tx = commitment_data.tx;
		let signature = {
			let channel_parameters = &self.funding.channel_transaction_parameters;
			self.context
				.holder_signer
				.sign_counterparty_commitment(
					channel_parameters,
					&counterparty_initial_commitment_tx,
					Vec::new(),
					Vec::new(),
					&self.context.secp_ctx,
				)
				.map(|(sig, _)| sig)
				.ok()
		};

		if signature.is_some() && self.context.signer_pending_funding {
			log_trace!(logger, "Counterparty commitment signature ready for funding_created message: clearing signer_pending_funding");
			self.context.signer_pending_funding = false;
		} else if signature.is_none() {
			log_trace!(logger, "funding_created awaiting signer; setting signer_pending_funding");
			self.context.signer_pending_funding = true;
		};

		signature.map(|signature| msgs::FundingCreated {
			temporary_channel_id: self.context.temporary_channel_id.unwrap(),
			funding_txid: self.funding.channel_transaction_parameters.funding_outpoint.as_ref().unwrap().txid,
			funding_output_index: self.funding.channel_transaction_parameters.funding_outpoint.as_ref().unwrap().index,
			signature,
		})
	}

	/// Updates channel state with knowledge of the funding transaction's txid/index, and generates
	/// a funding_created message for the remote peer.
	/// Panics if called at some time other than immediately after initial handshake, if called twice,
	/// or if called on an inbound channel.
	/// Note that channel_id changes during this call!
	/// Do NOT broadcast the funding transaction until after a successful funding_signed call!
	/// If an Err is returned, it is a ChannelError::Close.
	#[rustfmt::skip]
	pub fn get_funding_created<L: Logger>(&mut self, funding_transaction: Transaction, funding_txo: OutPoint, is_batch_funding: bool, logger: &L)
	-> Result<Option<msgs::FundingCreated>, (Self, ChannelError)> {
		if !self.funding.is_outbound() {
			panic!("Tried to create outbound funding_created message on an inbound channel!");
		}
		if !matches!(
			self.context.channel_state, ChannelState::NegotiatingFunding(flags)
			if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
		) {
			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)");
		}
		self.context.assert_no_commitment_advancement(self.unfunded_context.transaction_number(), "funding_created");

		self.funding.channel_transaction_parameters.funding_outpoint = Some(funding_txo);

		// Now that we're past error-generating stuff, update our local state:

		self.context.channel_state = ChannelState::FundingNegotiated(FundingNegotiatedFlags::new());
		self.context.channel_id = ChannelId::v1_from_funding_outpoint(funding_txo);

		// If the funding transaction is a coinbase transaction, we need to set the minimum depth to 100.
		// We can skip this if it is a zero-conf channel.
		if funding_transaction.is_coinbase() &&
			self.context.minimum_depth.unwrap_or(0) > 0 &&
			self.context.minimum_depth.unwrap_or(0) < COINBASE_MATURITY {
			self.funding.minimum_depth_override = Some(COINBASE_MATURITY);
		}

		debug_assert!(self.funding.funding_transaction.is_none());
		self.funding.funding_transaction = Some(funding_transaction);
		self.context.is_batch_funding = Some(()).filter(|_| is_batch_funding);

		let funding_created = self.get_funding_created_msg(logger);
		Ok(funding_created)
	}

	/// If we receive an error message, it may only be a rejection of the channel type we tried,
	/// not of our ability to open any channel at all. Thus, on error, we should first call this
	/// and see if we get a new `OpenChannel` message, otherwise the channel is failed.
	#[rustfmt::skip]
	pub(crate) fn maybe_handle_error_without_close<F: FeeEstimator, L: Logger>(
		&mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L,
		user_config: &UserConfig, their_features: &InitFeatures,
	) -> Result<msgs::OpenChannel, ()> {
		self.context.maybe_downgrade_channel_features(
			&mut self.funding, fee_estimator, user_config, their_features,
		)?;
		self.get_open_channel(chain_hash, logger).ok_or(())
	}

	/// Returns true if we can resume the channel by sending the [`msgs::OpenChannel`] again.
	pub fn is_resumable(&self) -> bool {
		!self.context.have_received_message()
			&& self.unfunded_context.transaction_number() == INITIAL_COMMITMENT_NUMBER
	}

	#[rustfmt::skip]
	pub fn get_open_channel<L: Logger>(
		&mut self, chain_hash: ChainHash, _logger: &L
	) -> Option<msgs::OpenChannel> {
		if !self.funding.is_outbound() {
			panic!("Tried to open a channel for an inbound channel?");
		}
		if self.context.have_received_message() {
			panic!("Cannot generate an open_channel after we've moved forward");
		}

		if self.unfunded_context.transaction_number() != INITIAL_COMMITMENT_NUMBER {
			panic!("Tried to send an open_channel for a channel that has already advanced");
		}

		let first_per_commitment_point = match self.unfunded_context.holder_commitment_point {
			Some(holder_commitment_point) if holder_commitment_point.can_advance() => {
				self.signer_pending_open_channel = false;
				holder_commitment_point.next_point()
			},
			_ => {
				log_trace!(_logger, "Unable to generate open_channel message, waiting for commitment point");
				self.signer_pending_open_channel = true;
				return None;
			}
		};
		let keys = self.funding.get_holder_pubkeys();

		Some(msgs::OpenChannel {
			common_fields: msgs::CommonOpenChannelFields {
				chain_hash,
				temporary_channel_id: self.context.channel_id,
				funding_satoshis: self.funding.get_value_satoshis(),
				dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
				max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
				htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
				commitment_feerate_sat_per_1000_weight: self.context.feerate_per_kw as u32,
				to_self_delay: self.funding.get_holder_selected_contest_delay(),
				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
				funding_pubkey: keys.funding_pubkey,
				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
				payment_basepoint: keys.payment_point,
				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
				first_per_commitment_point,
				channel_flags: if self.context.config.announce_for_forwarding {1} else {0},
				shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
					Some(script) => script.clone().into_inner(),
					None => Builder::new().into_script(),
				}),
				channel_type: Some(self.funding.get_channel_type().clone()),
			},
			push_msat: self.funding.get_value_satoshis() * 1000 - self.funding.value_to_self_msat,
			channel_reserve_satoshis: self.funding.holder_selected_channel_reserve_satoshis,
		})
	}

	// Message handlers
	pub fn accept_channel(
		&mut self, msg: &msgs::AcceptChannel, default_limits: &ChannelHandshakeLimits,
		their_features: &InitFeatures,
	) -> Result<(), ChannelError> {
		self.context.do_accept_channel_checks(
			&mut self.funding,
			default_limits,
			their_features,
			&msg.common_fields,
			msg.channel_reserve_satoshis,
		)
	}

	/// Handles a funding_signed message from the remote end.
	/// If this call is successful, broadcast the funding transaction (and not before!)
	pub fn funding_signed<L: Logger>(
		mut self, msg: &msgs::FundingSigned, best_block: BlockLocator, signer_provider: &SP,
		logger: &L,
	) -> Result<
		(FundedChannel<SP>, ChannelMonitor<SP::EcdsaSigner>),
		(OutboundV1Channel<SP>, ChannelError),
	> {
		if !self.funding.is_outbound() {
			let err = "Received funding_signed for an inbound channel?";
			return Err((self, ChannelError::close(err.to_owned())));
		}
		if !matches!(self.context.channel_state, ChannelState::FundingNegotiated(_)) {
			let err = "Received funding_signed in strange state!";
			return Err((self, ChannelError::close(err.to_owned())));
		}
		let mut holder_commitment_point = match self.unfunded_context.holder_commitment_point {
			Some(point) => point,
			None => {
				let err = "Received funding_signed before our first commitment point was available";
				return Err((self, ChannelError::close(err.to_owned())));
			},
		};
		self.context.assert_no_commitment_advancement(
			holder_commitment_point.next_transaction_number(),
			"funding_signed",
		);

		let (channel_monitor, _) = match self.initial_commitment_signed(
			self.context.channel_id(),
			msg.signature,
			&mut holder_commitment_point,
			best_block,
			signer_provider,
			logger,
		) {
			Ok(channel_monitor) => channel_monitor,
			Err(err) => return Err((self, err)),
		};

		log_info!(
			logger,
			"Received funding_signed from peer for channel {}",
			&self.context.channel_id()
		);

		let mut channel = FundedChannel {
			funding: self.funding,
			context: self.context,
			holder_commitment_point,
			pending_splice: None,
			quiescent_action: None,
		};

		let need_channel_ready = channel.check_get_channel_ready(0, logger).is_some()
			|| channel.context.signer_pending_channel_ready;
		channel.monitor_updating_paused(
			false,
			false,
			need_channel_ready,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);
		Ok((channel, channel_monitor))
	}

	/// Indicates that the signer may have some signatures for us, so we should retry if we're
	/// blocked.
	#[rustfmt::skip]
	pub fn signer_maybe_unblocked<L: Logger>(
		&mut self, chain_hash: ChainHash, logger: &L
	) -> (Option<msgs::OpenChannel>, Option<msgs::FundingCreated>) {
		// If we were pending a commitment point, retry the signer and advance to an
		// available state.
		if self.unfunded_context.holder_commitment_point.is_none() {
			self.unfunded_context.holder_commitment_point = HolderCommitmentPoint::new(&self.context.holder_signer, &self.context.secp_ctx);
		}
		if let Some(ref mut point) = self.unfunded_context.holder_commitment_point {
			if !point.can_advance() {
				point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
			}
		}
		let open_channel = if self.signer_pending_open_channel {
			log_trace!(logger, "Attempting to generate open_channel...");
			self.get_open_channel(chain_hash, logger)
		} else { None };
		let funding_created = if self.context.signer_pending_funding && self.funding.is_outbound() {
			log_trace!(logger, "Attempting to generate pending funding created...");
			self.get_funding_created_msg(logger)
		} else { None };
		(open_channel, funding_created)
	}

	/// Unsets the existing funding information.
	///
	/// The channel must be immediately shut down after this with a call to
	/// [`ChannelContext::force_shutdown`].
	pub fn unset_funding_info(&mut self) {
		debug_assert!(matches!(
			self.context.channel_state,
			ChannelState::FundingNegotiated(_) if self.context.interactive_tx_signing_session.is_none()
		));
		self.context.unset_funding_info(&mut self.funding);
	}
}

/// A not-yet-funded inbound (from counterparty) channel using V1 channel establishment.
pub(super) struct InboundV1Channel<SP: SignerProvider> {
	pub funding: FundingScope,
	pub context: ChannelContext<SP>,
	pub unfunded_context: UnfundedChannelContext,
	pub signer_pending_accept_channel: bool,
}

/// Fetches the [`ChannelTypeFeatures`] that will be used for a channel built from a given
/// [`msgs::CommonOpenChannelFields`].
pub(super) fn channel_type_from_open_channel(
	common_fields: &msgs::CommonOpenChannelFields, our_supported_features: &ChannelTypeFeatures,
) -> Result<ChannelTypeFeatures, ChannelError> {
	let channel_type = common_fields.channel_type.as_ref().ok_or_else(|| {
		ChannelError::close("option_channel_type assumed to be supported".to_owned())
	})?;

	if channel_type.supports_any_optional_bits() {
		return Err(ChannelError::close(
			"Channel Type field contained optional bits - this is not allowed".to_owned(),
		));
	}

	// We only support the channel types defined by the `ChannelManager` in
	// `provided_channel_type_features`. The channel type must always support
	// `static_remote_key`, either implicitly with `option_zero_fee_commitments`
	// or explicitly.
	if !channel_type.requires_static_remote_key()
		&& !channel_type.requires_anchor_zero_fee_commitments()
	{
		return Err(ChannelError::close(
			"Channel Type was not understood - we require static remote key".to_owned(),
		));
	}
	if channel_type.requires_anchors_zero_fee_htlc_tx()
		&& channel_type.requires_anchor_zero_fee_commitments()
	{
		return Err(ChannelError::close(
			"Channel Type cannot require both anchor types".to_owned(),
		));
	}
	// Make sure we support all of the features behind the channel type.
	if channel_type.requires_unknown_bits_from(&our_supported_features) {
		return Err(ChannelError::close("Channel Type contains unsupported features".to_owned()));
	}
	let announce_for_forwarding = if (common_fields.channel_flags & 1) == 1 { true } else { false };
	if channel_type.requires_scid_privacy() && announce_for_forwarding {
		return Err(ChannelError::close(
			"SCID Alias/Privacy Channel Type cannot be set on a public channel".to_owned(),
		));
	}
	Ok(channel_type.clone())
}

impl<SP: SignerProvider> InboundV1Channel<SP> {
	/// Creates a new channel from a remote sides' request for one.
	/// Assumes chain_hash has already been checked and corresponds with what we expect!
	pub fn new<ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
		counterparty_node_id: PublicKey, our_supported_features: &ChannelTypeFeatures,
		their_features: &InitFeatures, msg: &msgs::OpenChannel, user_id: u128, config: &UserConfig,
		current_chain_height: u32, logger: &L,
		trusted_channel_features: Option<TrustedChannelFeatures>,
	) -> Result<InboundV1Channel<SP>, ChannelError> {
		let logger = WithContext::from(
			logger,
			Some(counterparty_node_id),
			Some(msg.common_fields.temporary_channel_id),
			None,
		);

		// First check the channel type is known, failing before we do anything else if we don't
		// support this channel type.
		let channel_type =
			channel_type_from_open_channel(&msg.common_fields, our_supported_features)?;

		let holder_selected_channel_reserve_satoshis =
			get_holder_selected_channel_reserve_satoshis(
				msg.common_fields.funding_satoshis,
				msg.common_fields.dust_limit_satoshis,
				config,
				trusted_channel_features.is_some_and(|f| f.is_0reserve()),
			)
			.map_err(|()| {
				ChannelError::close(format!(
					"The channel value {} is smaller than either their dust \
					limit {}, or {MIN_THEIR_CHAN_RESERVE_SATOSHIS}",
					msg.common_fields.funding_satoshis, msg.common_fields.dust_limit_satoshis,
				))
			})?;
		let counterparty_pubkeys = ChannelPublicKeys {
			funding_pubkey: msg.common_fields.funding_pubkey,
			revocation_basepoint: RevocationBasepoint::from(msg.common_fields.revocation_basepoint),
			payment_point: msg.common_fields.payment_basepoint,
			delayed_payment_basepoint: DelayedPaymentBasepoint::from(
				msg.common_fields.delayed_payment_basepoint,
			),
			htlc_basepoint: HtlcBasepoint::from(msg.common_fields.htlc_basepoint),
		};

		let (funding, context) = ChannelContext::new_for_inbound_channel(
			fee_estimator,
			entropy_source,
			signer_provider,
			counterparty_node_id,
			their_features,
			user_id,
			config,
			current_chain_height,
			&&logger,
			trusted_channel_features,
			0,
			counterparty_pubkeys,
			channel_type,
			holder_selected_channel_reserve_satoshis,
			msg.channel_reserve_satoshis,
			msg.push_msat,
			msg.common_fields.clone(),
		)?;
		let unfunded_context = UnfundedChannelContext {
			unfunded_channel_age_ticks: 0,
			holder_commitment_point: HolderCommitmentPoint::new(
				&context.holder_signer,
				&context.secp_ctx,
			),
		};
		let chan =
			Self { funding, context, unfunded_context, signer_pending_accept_channel: false };
		Ok(chan)
	}

	/// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannel`] message which
	/// should be sent back to the counterparty node.
	///
	/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
	pub fn accept_inbound_channel<L: Logger>(&mut self, logger: &L) -> Option<msgs::AcceptChannel> {
		if self.funding.is_outbound() {
			panic!("Tried to send accept_channel for an outbound channel?");
		}
		if !matches!(
			self.context.channel_state, ChannelState::NegotiatingFunding(flags)
			if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
		) {
			panic!("Tried to send accept_channel after channel had moved forward");
		}
		if self.unfunded_context.transaction_number() != INITIAL_COMMITMENT_NUMBER {
			panic!("Tried to send an accept_channel for a channel that has already advanced");
		}

		self.generate_accept_channel_message(logger)
	}

	/// This function is used to explicitly generate a [`msgs::AcceptChannel`] message for an
	/// inbound channel. If the intention is to accept an inbound channel, use
	/// [`InboundV1Channel::accept_inbound_channel`] instead.
	///
	/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
	#[rustfmt::skip]
	fn generate_accept_channel_message<L: Logger>(
		&mut self, _logger: &L
	) -> Option<msgs::AcceptChannel> {
		let first_per_commitment_point = match self.unfunded_context.holder_commitment_point {
			Some(holder_commitment_point) if holder_commitment_point.can_advance() => {
				self.signer_pending_accept_channel = false;
				holder_commitment_point.next_point()
			},
			_ => {
				log_trace!(_logger, "Unable to generate accept_channel message, waiting for commitment point");
				self.signer_pending_accept_channel = true;
				return None;
			}
		};
		let keys = self.funding.get_holder_pubkeys();

		Some(msgs::AcceptChannel {
			common_fields: msgs::CommonAcceptChannelFields {
				temporary_channel_id: self.context.channel_id,
				dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
				max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
				htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
				minimum_depth: self.context.minimum_depth.unwrap(),
				to_self_delay: self.funding.get_holder_selected_contest_delay(),
				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
				funding_pubkey: keys.funding_pubkey,
				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
				payment_basepoint: keys.payment_point,
				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
				first_per_commitment_point,
				shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
					Some(script) => script.clone().into_inner(),
					None => Builder::new().into_script(),
				}),
				channel_type: Some(self.funding.get_channel_type().clone()),
			},
			channel_reserve_satoshis: self.funding.holder_selected_channel_reserve_satoshis,
		})
	}

	/// Enables the possibility for tests to extract a [`msgs::AcceptChannel`] message for an
	/// inbound channel without accepting it.
	///
	/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
	#[cfg(test)]
	pub fn get_accept_channel_message<L: Logger>(
		&mut self, logger: &L,
	) -> Option<msgs::AcceptChannel> {
		self.generate_accept_channel_message(logger)
	}

	pub fn funding_created<L: Logger>(
		mut self, msg: &msgs::FundingCreated, best_block: BlockLocator, signer_provider: &SP,
		logger: &L,
	) -> Result<
		(FundedChannel<SP>, Option<msgs::FundingSigned>, ChannelMonitor<SP::EcdsaSigner>),
		(Self, ChannelError),
	> {
		if self.funding.is_outbound() {
			let err = "Received funding_created for an outbound channel?";
			return Err((self, ChannelError::close(err.to_owned())));
		}
		if !matches!(
			self.context.channel_state, ChannelState::NegotiatingFunding(flags)
			if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
		) {
			// BOLT 2 says that if we disconnect before we send funding_signed we SHOULD NOT
			// remember the channel, so it's safe to just send an error_message here and drop the
			// channel.
			let err = "Received funding_created after we got the channel!";
			return Err((self, ChannelError::close(err.to_owned())));
		}
		let mut holder_commitment_point = match self.unfunded_context.holder_commitment_point {
			Some(point) => point,
			None => {
				let err =
					"Received funding_created before our first commitment point was available";
				return Err((self, ChannelError::close(err.to_owned())));
			},
		};
		self.context.assert_no_commitment_advancement(
			holder_commitment_point.next_transaction_number(),
			"funding_created",
		);

		let funding_txo = OutPoint { txid: msg.funding_txid, index: msg.funding_output_index };
		self.funding.channel_transaction_parameters.funding_outpoint = Some(funding_txo);

		let (channel_monitor, counterparty_initial_commitment_tx) = match self
			.initial_commitment_signed(
				ChannelId::v1_from_funding_outpoint(funding_txo),
				msg.signature,
				&mut holder_commitment_point,
				best_block,
				signer_provider,
				logger,
			) {
			Ok(channel_monitor) => channel_monitor,
			Err(err) => return Err((self, err)),
		};

		let funding_signed = self.context.get_funding_signed_msg(
			&self.funding.channel_transaction_parameters,
			logger,
			counterparty_initial_commitment_tx,
		);

		log_info!(
			logger,
			"{} funding_signed for peer for channel {}",
			if funding_signed.is_some() { "Generated" } else { "Waiting for signature on" },
			&self.context.channel_id()
		);

		// Promote the channel to a full-fledged one now that we have updated the state and have a
		// `ChannelMonitor`.
		let mut channel = FundedChannel {
			funding: self.funding,
			context: self.context,
			holder_commitment_point,
			pending_splice: None,
			quiescent_action: None,
		};
		let need_channel_ready = channel.check_get_channel_ready(0, logger).is_some()
			|| channel.context.signer_pending_channel_ready;
		channel.monitor_updating_paused(
			false,
			false,
			need_channel_ready,
			Vec::new(),
			Vec::new(),
			Vec::new(),
			logger,
		);

		Ok((channel, funding_signed, channel_monitor))
	}

	/// Indicates that the signer may have some signatures for us, so we should retry if we're
	/// blocked.
	#[rustfmt::skip]
	pub fn signer_maybe_unblocked<L: Logger>(
		&mut self, logger: &L
	) -> Option<msgs::AcceptChannel> {
		if self.unfunded_context.holder_commitment_point.is_none() {
			self.unfunded_context.holder_commitment_point = HolderCommitmentPoint::new(&self.context.holder_signer, &self.context.secp_ctx);
		}
		if let Some(ref mut point) = self.unfunded_context.holder_commitment_point {
			if !point.can_advance() {
				point.try_resolve_pending(&self.context.holder_signer, &self.context.secp_ctx, logger);
			}
		}
		if self.signer_pending_accept_channel {
			log_trace!(logger, "Attempting to generate accept_channel...");
			self.generate_accept_channel_message(logger)
		} else { None }
	}
}

// A not-yet-funded channel using V2 channel establishment.
pub(super) struct PendingV2Channel<SP: SignerProvider> {
	pub funding: FundingScope,
	pub context: ChannelContext<SP>,
	pub unfunded_context: UnfundedChannelContext,
	pub funding_negotiation_context: FundingNegotiationContext,
	/// The current interactive transaction construction session under negotiation.
	pub interactive_tx_constructor: Option<InteractiveTxConstructor>,
}

impl<SP: SignerProvider> PendingV2Channel<SP> {
	#[allow(dead_code)] // TODO(dual_funding): Remove once creating V2 channels is enabled.
	#[rustfmt::skip]
	pub fn new_outbound<ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
		counterparty_node_id: PublicKey, their_features: &InitFeatures, funding_satoshis: u64,
		funding_inputs: Vec<ConfirmedUtxo>, user_id: u128, config: &UserConfig,
		current_chain_height: u32, outbound_scid_alias: u64, funding_confirmation_target: ConfirmationTarget,
		logger: L, trusted_channel_features: Option<TrustedChannelFeatures>,
	) -> Result<Self, APIError> {
		let channel_keys_id = signer_provider.generate_channel_keys_id(false, user_id);
		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);

		let temporary_channel_id_fn = Some(|pubkeys: &ChannelPublicKeys| {
			ChannelId::temporary_v2_from_revocation_basepoint(&pubkeys.revocation_basepoint)
		});

		let holder_selected_channel_reserve_satoshis = get_v2_channel_reserve_satoshis(
			funding_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS, trusted_channel_features.is_some_and(|f| f.is_0reserve())
		).map_err(|()| APIError::APIMisuseError {
			err: format!(
				"The channel value {funding_satoshis} is smaller than their dust \
				limit {MIN_CHAN_DUST_LIMIT_SATOSHIS}"
			)
		})?;
		let funding_feerate_sat_per_1000_weight = fee_estimator.bounded_sat_per_1000_weight(funding_confirmation_target);
		let funding_tx_locktime = LockTime::from_height(current_chain_height)
			.map_err(|_| APIError::APIMisuseError {
				err: format!(
					"Provided current chain height of {} doesn't make sense for a height-based timelock for the funding transaction",
					current_chain_height) })?;

		let (funding, context) = ChannelContext::new_for_outbound_channel(
			fee_estimator,
			entropy_source,
			signer_provider,
			counterparty_node_id,
			their_features,
			funding_satoshis,
			0,
			user_id,
			config,
			current_chain_height,
			outbound_scid_alias,
			temporary_channel_id_fn,
			holder_selected_channel_reserve_satoshis,
			channel_keys_id,
			holder_signer,
			logger,
		)?;
		let unfunded_context = UnfundedChannelContext {
			unfunded_channel_age_ticks: 0,
			holder_commitment_point: HolderCommitmentPoint::new(&context.holder_signer, &context.secp_ctx),
		};
		let funding_negotiation_context = FundingNegotiationContext {
			is_initiator: true,
			our_funding_contribution: SignedAmount::from_sat(funding_satoshis as i64),
			funding_tx_locktime,
			funding_feerate_sat_per_1000_weight,
			shared_funding_input: None,
			our_funding_inputs: funding_inputs,
			our_funding_outputs: Vec::new(),
		};
		let chan = Self {
			funding,
			context,
			unfunded_context,
			funding_negotiation_context,
			interactive_tx_constructor: None,
		};
		Ok(chan)
	}

	/// If we receive an error message, it may only be a rejection of the channel type we tried,
	/// not of our ability to open any channel at all. Thus, on error, we should first call this
	/// and see if we get a new `OpenChannelV2` message, otherwise the channel is failed.
	pub(crate) fn maybe_handle_error_without_close<F: FeeEstimator>(
		&mut self, chain_hash: ChainHash, fee_estimator: &LowerBoundedFeeEstimator<F>,
		user_config: &UserConfig, their_features: &InitFeatures,
	) -> Result<msgs::OpenChannelV2, ()> {
		self.context.maybe_downgrade_channel_features(
			&mut self.funding,
			fee_estimator,
			user_config,
			their_features,
		)?;
		Ok(self.get_open_channel_v2(chain_hash))
	}

	#[rustfmt::skip]
	pub fn get_open_channel_v2(&self, chain_hash: ChainHash) -> msgs::OpenChannelV2 {
		if !self.funding.is_outbound() {
			debug_assert!(false, "Tried to send open_channel2 for an inbound channel?");
		}

		if self.context.have_received_message() {
			debug_assert!(false, "Cannot generate an open_channel2 after we've moved forward");
		}

		if self.unfunded_context.transaction_number() != INITIAL_COMMITMENT_NUMBER {
			debug_assert!(false, "Tried to send an open_channel2 for a channel that has already advanced");
		}

		let first_per_commitment_point = self.context.holder_signer
			.get_per_commitment_point(self.unfunded_context.transaction_number(),
				&self.context.secp_ctx)
				.expect("TODO: async signing is not yet supported for commitment points in v2 channel establishment");
		let second_per_commitment_point = self.context.holder_signer
			.get_per_commitment_point(self.unfunded_context.transaction_number() - 1,
				&self.context.secp_ctx)
				.expect("TODO: async signing is not yet supported for commitment points in v2 channel establishment");
		let keys = self.funding.get_holder_pubkeys();

		msgs::OpenChannelV2 {
			common_fields: msgs::CommonOpenChannelFields {
				chain_hash,
				temporary_channel_id: self.context.temporary_channel_id.unwrap(),
				funding_satoshis: self.funding.get_value_satoshis(),
				dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
				max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
				htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
				commitment_feerate_sat_per_1000_weight: self.context.feerate_per_kw,
				to_self_delay: self.funding.get_holder_selected_contest_delay(),
				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
				funding_pubkey: keys.funding_pubkey,
				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
				payment_basepoint: keys.payment_point,
				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
				first_per_commitment_point,
				channel_flags: if self.context.config.announce_for_forwarding {1} else {0},
				shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
					Some(script) => script.clone().into_inner(),
					None => Builder::new().into_script(),
				}),
				channel_type: Some(self.funding.get_channel_type().clone()),
			},
			funding_feerate_sat_per_1000_weight: self.context.feerate_per_kw,
			second_per_commitment_point,
			locktime: self.funding_negotiation_context.funding_tx_locktime.to_consensus_u32(),
			require_confirmed_inputs: None,
			disable_channel_reserve: (self.funding.holder_selected_channel_reserve_satoshis == 0).then_some(()),
		}
	}

	/// Creates a new dual-funded channel from a remote side's request for one.
	/// Assumes chain_hash has already been checked and corresponds with what we expect!
	/// TODO(dual_funding): Allow contributions, pass intended amount and inputs
	#[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
	#[rustfmt::skip]
	pub fn new_inbound<ES: EntropySource, F: FeeEstimator, L: Logger>(
		fee_estimator: &LowerBoundedFeeEstimator<F>, entropy_source: &ES, signer_provider: &SP,
		holder_node_id: PublicKey, counterparty_node_id: PublicKey, our_supported_features: &ChannelTypeFeatures,
		their_features: &InitFeatures, msg: &msgs::OpenChannelV2,
		user_id: u128, config: &UserConfig, current_chain_height: u32, logger: &L, trusted_channel_features: Option<TrustedChannelFeatures>,
	) -> Result<Self, ChannelError> {
		// TODO(dual_funding): Take these as input once supported
		let (our_funding_contribution, our_funding_contribution_sats) = (SignedAmount::ZERO, 0u64);
		let our_funding_inputs = Vec::new();

		let channel_value_satoshis =
			our_funding_contribution_sats.saturating_add(msg.common_fields.funding_satoshis);
		let counterparty_selected_channel_reserve_satoshis = get_v2_channel_reserve_satoshis(
			channel_value_satoshis, MIN_CHAN_DUST_LIMIT_SATOSHIS, msg.disable_channel_reserve.is_some()
		).map_err(|()| ChannelError::close(format!(
			"The channel value {channel_value_satoshis} is smaller than our dust limit {MIN_CHAN_DUST_LIMIT_SATOSHIS}"
		)))?;
		let their_dust_limit_satoshis = msg.common_fields.dust_limit_satoshis;
		let holder_selected_channel_reserve_satoshis = get_v2_channel_reserve_satoshis(
			channel_value_satoshis, their_dust_limit_satoshis, trusted_channel_features.is_some_and(|f| f.is_0reserve())
		).map_err(|()| ChannelError::close(format!(
			"The channel value {channel_value_satoshis} is smaller than their dust limit {their_dust_limit_satoshis}"
		)))?;

		let channel_type = channel_type_from_open_channel(&msg.common_fields, our_supported_features)?;

		let counterparty_pubkeys = ChannelPublicKeys {
			funding_pubkey: msg.common_fields.funding_pubkey,
			revocation_basepoint: RevocationBasepoint(msg.common_fields.revocation_basepoint),
			payment_point: msg.common_fields.payment_basepoint,
			delayed_payment_basepoint: DelayedPaymentBasepoint(msg.common_fields.delayed_payment_basepoint),
			htlc_basepoint: HtlcBasepoint(msg.common_fields.htlc_basepoint)
		};

		let (funding, mut context) = ChannelContext::new_for_inbound_channel(
			fee_estimator,
			entropy_source,
			signer_provider,
			counterparty_node_id,
			their_features,
			user_id,
			config,
			current_chain_height,
			logger,
			trusted_channel_features,
			our_funding_contribution_sats,
			counterparty_pubkeys,
			channel_type,
			holder_selected_channel_reserve_satoshis,
			counterparty_selected_channel_reserve_satoshis,
			0 /* push_msat not used in dual-funding */,
			msg.common_fields.clone(),
		)?;
		let channel_id = ChannelId::v2_from_revocation_basepoints(
			&funding.get_holder_pubkeys().revocation_basepoint,
			&funding.get_counterparty_pubkeys().revocation_basepoint);
		context.channel_id = channel_id;

		let funding_negotiation_context = FundingNegotiationContext {
			is_initiator: false,
			our_funding_contribution,
			funding_tx_locktime: LockTime::from_consensus(msg.locktime),
			funding_feerate_sat_per_1000_weight: msg.funding_feerate_sat_per_1000_weight,
			shared_funding_input: None,
			our_funding_inputs: our_funding_inputs.clone(),
			our_funding_outputs: Vec::new(),
		};
		let shared_funding_output = TxOut {
			value: Amount::from_sat(funding.get_value_satoshis()),
			script_pubkey: funding.get_funding_redeemscript().to_p2wsh(),
		};

		let interactive_tx_constructor = Some(InteractiveTxConstructor::new_for_inbound(
			InteractiveTxConstructorArgs {
				entropy_source,
				holder_node_id,
				counterparty_node_id,
				channel_id: context.channel_id,
				feerate_sat_per_kw: funding_negotiation_context.funding_feerate_sat_per_1000_weight,
				funding_tx_locktime: funding_negotiation_context.funding_tx_locktime,
				inputs_to_contribute: our_funding_inputs,
				shared_funding_input: None,
				shared_funding_output: SharedOwnedOutput::new(shared_funding_output, our_funding_contribution_sats),
				outputs_to_contribute: funding_negotiation_context.our_funding_outputs.clone(),
			}
		));

		let unfunded_context = UnfundedChannelContext {
			unfunded_channel_age_ticks: 0,
			holder_commitment_point: HolderCommitmentPoint::new(&context.holder_signer, &context.secp_ctx),
		};
		Ok(Self {
			funding,
			context,
			funding_negotiation_context,
			interactive_tx_constructor,
			unfunded_context,
		})
	}

	/// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannelV2`] message which
	/// should be sent back to the counterparty node.
	///
	/// [`msgs::AcceptChannelV2`]: crate::ln::msgs::AcceptChannelV2
	#[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
	#[rustfmt::skip]
	pub fn accept_inbound_dual_funded_channel(&self) -> msgs::AcceptChannelV2 {
		if self.funding.is_outbound() {
			debug_assert!(false, "Tried to send accept_channel for an outbound channel?");
		}
		if !matches!(
			self.context.channel_state, ChannelState::NegotiatingFunding(flags)
			if flags == (NegotiatingFundingFlags::OUR_INIT_SENT | NegotiatingFundingFlags::THEIR_INIT_SENT)
		) {
			debug_assert!(false, "Tried to send accept_channel2 after channel had moved forward");
		}
		if self.unfunded_context.transaction_number() != INITIAL_COMMITMENT_NUMBER {
			debug_assert!(false, "Tried to send an accept_channel2 for a channel that has already advanced");
		}

		self.generate_accept_channel_v2_message()
	}

	/// This function is used to explicitly generate a [`msgs::AcceptChannelV2`] message for an
	/// inbound dual-funded channel. If the intention is to accept a V1 established inbound channel,
	/// use [`InboundV1Channel::accept_inbound_channel`] instead.
	///
	/// [`msgs::AcceptChannelV2`]: crate::ln::msgs::AcceptChannelV2
	#[allow(dead_code)] // TODO(dual_funding): Remove once V2 channels is enabled.
	fn generate_accept_channel_v2_message(&self) -> msgs::AcceptChannelV2 {
		let first_per_commitment_point = self.context.holder_signer.get_per_commitment_point(
			self.unfunded_context.transaction_number(), &self.context.secp_ctx)
			.expect("TODO: async signing is not yet supported for commitment points in v2 channel establishment");
		let second_per_commitment_point = self.context.holder_signer.get_per_commitment_point(
			self.unfunded_context.transaction_number() - 1, &self.context.secp_ctx)
			.expect("TODO: async signing is not yet supported for commitment points in v2 channel establishment");
		let keys = self.funding.get_holder_pubkeys();

		msgs::AcceptChannelV2 {
			common_fields: msgs::CommonAcceptChannelFields {
				temporary_channel_id: self.context.temporary_channel_id.unwrap(),
				dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
				max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
				htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
				minimum_depth: self.context.minimum_depth.unwrap(),
				to_self_delay: self.funding.get_holder_selected_contest_delay(),
				max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
				funding_pubkey: keys.funding_pubkey,
				revocation_basepoint: keys.revocation_basepoint.to_public_key(),
				payment_basepoint: keys.payment_point,
				delayed_payment_basepoint: keys.delayed_payment_basepoint.to_public_key(),
				htlc_basepoint: keys.htlc_basepoint.to_public_key(),
				first_per_commitment_point,
				shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
					Some(script) => script.clone().into_inner(),
					None => Builder::new().into_script(),
				}),
				channel_type: Some(self.funding.get_channel_type().clone()),
			},
			funding_satoshis: self.funding_negotiation_context.our_funding_contribution.to_sat()
				as u64,
			second_per_commitment_point,
			require_confirmed_inputs: None,
			disable_channel_reserve: (self.funding.holder_selected_channel_reserve_satoshis == 0)
				.then_some(()),
		}
	}

	/// Enables the possibility for tests to extract a [`msgs::AcceptChannelV2`] message for an
	/// inbound channel without accepting it.
	///
	/// [`msgs::AcceptChannelV2`]: crate::ln::msgs::AcceptChannelV2
	#[cfg(test)]
	#[allow(dead_code)] // TODO(dual_funding): Remove once contribution to V2 channels is enabled.
	pub fn get_accept_channel_v2_message(&self) -> msgs::AcceptChannelV2 {
		self.generate_accept_channel_v2_message()
	}
}

// Unfunded channel utilities

pub(super) fn get_initial_channel_type(
	config: &UserConfig, their_features: &InitFeatures,
) -> ChannelTypeFeatures {
	// The default channel type (ie the first one we try) depends on whether the channel is
	// public - if it is, we just go with `only_static_remotekey` as it's the only option
	// available. If it's private, we first try `scid_privacy` as it provides better privacy
	// with no other changes, and fall back to `only_static_remotekey`.
	let mut ret = ChannelTypeFeatures::only_static_remote_key();
	if !config.channel_handshake_config.announce_for_forwarding
		&& config.channel_handshake_config.negotiate_scid_privacy
		&& their_features.supports_scid_privacy()
	{
		ret.set_scid_privacy_required();
	}

	// Optionally, if the user would like to negotiate `option_zero_fee_commitments` we set it now.
	// If they don't understand it (or we don't want it), we check the same conditions for
	// `option_anchors_zero_fee_htlc_tx`. The counterparty can still refuse the channel and we'll
	// try to fall back (all the way to `only_static_remotekey`).
	if config.channel_handshake_config.negotiate_anchor_zero_fee_commitments
		&& their_features.supports_anchor_zero_fee_commitments()
	{
		ret.set_anchor_zero_fee_commitments_required();
		// `option_static_remote_key` is assumed by `option_zero_fee_commitments`.
		ret.clear_static_remote_key();
	} else if config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx
		&& their_features.supports_anchors_zero_fee_htlc_tx()
	{
		ret.set_anchors_zero_fee_htlc_tx_required();
	}

	ret
}

const SERIALIZATION_VERSION: u8 = 4;
const MIN_SERIALIZATION_VERSION: u8 = 4;

impl Writeable for ChannelUpdateStatus {
	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
		// We only care about writing out the current state as it was announced, ie only either
		// Enabled or Disabled. In the case of DisabledStaged, we most recently announced the
		// channel as enabled, so we write 0. For EnabledStaged, we similarly write a 1.
		match self {
			ChannelUpdateStatus::Enabled => 0u8.write(writer)?,
			ChannelUpdateStatus::DisabledStaged(_) => 0u8.write(writer)?,
			ChannelUpdateStatus::EnabledStaged(_) => 1u8.write(writer)?,
			ChannelUpdateStatus::Disabled => 1u8.write(writer)?,
		}
		Ok(())
	}
}

impl Readable for ChannelUpdateStatus {
	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
		Ok(match <u8 as Readable>::read(reader)? {
			0 => ChannelUpdateStatus::Enabled,
			1 => ChannelUpdateStatus::Disabled,
			_ => return Err(DecodeError::InvalidValue),
		})
	}
}

impl Writeable for AnnouncementSigsState {
	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
		// We only care about writing out the current state as if we had just disconnected, at
		// which point we always set anything but AnnouncementSigsReceived to NotSent.
		match self {
			AnnouncementSigsState::NotSent => 0u8.write(writer),
			AnnouncementSigsState::MessageSent => 0u8.write(writer),
			AnnouncementSigsState::Committed => 0u8.write(writer),
			AnnouncementSigsState::PeerReceived => 1u8.write(writer),
		}
	}
}

impl Readable for AnnouncementSigsState {
	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
		Ok(match <u8 as Readable>::read(reader)? {
			0 => AnnouncementSigsState::NotSent,
			1 => AnnouncementSigsState::PeerReceived,
			_ => return Err(DecodeError::InvalidValue),
		})
	}
}

impl<SP: SignerProvider> Writeable for FundedChannel<SP> {
	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
		// Note that we write out as if remove_uncommitted_htlcs_and_mark_paused had just been
		// called.

		write_ver_prefix!(writer, SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);

		// `user_id` used to be a single u64 value. In order to remain backwards compatible with
		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We write
		// the low bytes now and the optional high bytes later.
		let user_id_low = self.context.user_id as u64;
		user_id_low.write(writer)?;

		// Version 1 deserializers expected to read parts of the config object here. Version 2
		// deserializers (0.0.99) now read config through TLVs, and as we now require them for
		// `minimum_depth` we simply write dummy values here.
		writer.write_all(&[0; 8])?;

		self.context.channel_id.write(writer)?;
		{
			let mut channel_state = self.context.channel_state;
			match channel_state {
				ChannelState::AwaitingChannelReady(_) => {},
				ChannelState::ChannelReady(_) => {
					channel_state.clear_local_stfu_sent();
					channel_state.clear_remote_stfu_sent();
					if self.should_reset_pending_splice_state(true)
						|| !self.has_pending_splice_awaiting_signatures()
					{
						// We shouldn't be quiescent anymore upon reconnecting if:
						// - We were in quiescence but a splice/RBF was never negotiated or
						// - We were in quiescence but the splice negotiation failed due to
						// disconnecting
						channel_state.clear_quiescent();
					}
				},
				ChannelState::FundingNegotiated(_)
					if self.context.interactive_tx_signing_session.is_some() => {},
				_ => debug_assert!(false, "Pre-funded/shutdown channels should not be written"),
			}
			channel_state.set_peer_disconnected();
			channel_state.to_u32().write(writer)?;
		}
		self.funding.get_value_satoshis().write(writer)?;

		self.context.latest_monitor_update_id.write(writer)?;

		// Write out the old serialization for shutdown_pubkey for backwards compatibility, if
		// deserialized from that format.
		let shutdown_scriptpubkey = self.context.shutdown_scriptpubkey.as_ref();
		match shutdown_scriptpubkey.and_then(|script| script.as_legacy_pubkey()) {
			Some(shutdown_pubkey) => shutdown_pubkey.write(writer)?,
			None => [0u8; PUBLIC_KEY_SIZE].write(writer)?,
		}
		self.context.destination_script.write(writer)?;

		self.holder_commitment_point.next_transaction_number().write(writer)?;
		self.context.counterparty_next_commitment_transaction_number.write(writer)?;
		self.funding.value_to_self_msat.write(writer)?;

		let mut dropped_inbound_htlcs = 0;
		for htlc in self.context.pending_inbound_htlcs.iter() {
			if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
				dropped_inbound_htlcs += 1;
			}
		}
		let mut removed_htlc_attribution_data: Vec<&Option<AttributionData>> = Vec::new();
		#[cfg_attr(not(test), allow(unused_mut))]
		let mut inbound_committed_update_adds: Vec<&InboundUpdateAdd> = Vec::new();
		(self.context.pending_inbound_htlcs.len() as u64 - dropped_inbound_htlcs).write(writer)?;
		for htlc in self.context.pending_inbound_htlcs.iter() {
			if let &InboundHTLCState::RemoteAnnounced(_) = &htlc.state {
				continue; // Drop
			}
			htlc.htlc_id.write(writer)?;
			htlc.amount_msat.write(writer)?;
			htlc.cltv_expiry.write(writer)?;
			htlc.payment_hash.write(writer)?;
			match &htlc.state {
				&InboundHTLCState::RemoteAnnounced(_) => unreachable!(),
				&InboundHTLCState::AwaitingRemoteRevokeToAnnounce(ref htlc_resolution) => {
					1u8.write(writer)?;
					htlc_resolution.write(writer)?;
				},
				&InboundHTLCState::AwaitingAnnouncedRemoteRevoke(ref htlc_resolution) => {
					2u8.write(writer)?;
					htlc_resolution.write(writer)?;
				},
				&InboundHTLCState::Committed { update_add_htlc: ref _update_add } => {
					3u8.write(writer)?;
					#[cfg(test)]
					inbound_committed_update_adds.push(_update_add);
				},
				&InboundHTLCState::LocalRemoved(ref removal_reason) => {
					4u8.write(writer)?;
					match removal_reason {
						InboundHTLCRemovalReason::FailRelay(msgs::OnionErrorPacket {
							data,
							attribution_data,
						}) => {
							0u8.write(writer)?;
							data.write(writer)?;
							removed_htlc_attribution_data.push(&attribution_data);
						},
						InboundHTLCRemovalReason::FailMalformed {
							sha256_of_onion: hash,
							failure_code: code,
						} => {
							1u8.write(writer)?;
							(hash, code).write(writer)?;
						},
						InboundHTLCRemovalReason::Fulfill { preimage, attribution_data } => {
							2u8.write(writer)?;
							preimage.write(writer)?;
							removed_htlc_attribution_data.push(&attribution_data);
						},
					}
				},
			}
		}

		// The elements of this vector will always be `Some` starting in 0.2,
		// but we still serialize the option to maintain backwards compatibility
		let mut preimages: Vec<Option<&PaymentPreimage>> = vec![];
		let mut fulfill_attribution_data = vec![];
		let mut pending_outbound_skimmed_fees: Vec<Option<u64>> = Vec::new();
		let mut pending_outbound_blinding_points: Vec<Option<PublicKey>> = Vec::new();
		let mut pending_outbound_held_htlc_flags: Vec<Option<()>> = Vec::new();
		let mut pending_outbound_accountable: Vec<bool> = Vec::new();

		(self.context.pending_outbound_htlcs.len() as u64).write(writer)?;
		for htlc in self.context.pending_outbound_htlcs.iter() {
			htlc.htlc_id.write(writer)?;
			htlc.amount_msat.write(writer)?;
			htlc.cltv_expiry.write(writer)?;
			htlc.payment_hash.write(writer)?;
			htlc.source.write(writer)?;
			match &htlc.state {
				&OutboundHTLCState::LocalAnnounced(ref onion_packet) => {
					0u8.write(writer)?;
					onion_packet.write(writer)?;
				},
				&OutboundHTLCState::Committed => {
					1u8.write(writer)?;
				},
				&OutboundHTLCState::RemoteRemoved(_) => {
					// Treat this as a Committed because we haven't received the CS - they'll
					// resend the claim/fail on reconnect as we all (hopefully) the missing CS.
					1u8.write(writer)?;
				},
				&OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref outcome) => {
					3u8.write(writer)?;
					if let OutboundHTLCOutcome::Success { preimage, attribution_data } = outcome {
						preimages.push(Some(preimage));
						fulfill_attribution_data.push(attribution_data);
					}
					let reason: Option<&HTLCFailReason> = outcome.into();
					reason.write(writer)?;
				},
				&OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref outcome) => {
					4u8.write(writer)?;
					if let OutboundHTLCOutcome::Success { preimage, attribution_data } = outcome {
						preimages.push(Some(preimage));
						fulfill_attribution_data.push(attribution_data);
					}
					let reason: Option<&HTLCFailReason> = outcome.into();
					reason.write(writer)?;
				},
			}
			pending_outbound_skimmed_fees.push(htlc.skimmed_fee_msat);
			pending_outbound_blinding_points.push(htlc.blinding_point);
			pending_outbound_held_htlc_flags.push(htlc.hold_htlc);
			pending_outbound_accountable.push(htlc.accountable);
		}

		let holding_cell_htlc_update_count = self.context.holding_cell_htlc_updates.len();
		let mut holding_cell_skimmed_fees: Vec<Option<u64>> =
			Vec::with_capacity(holding_cell_htlc_update_count);
		let mut holding_cell_blinding_points: Vec<Option<PublicKey>> =
			Vec::with_capacity(holding_cell_htlc_update_count);
		let mut holding_cell_attribution_data: Vec<Option<&AttributionData>> =
			Vec::with_capacity(holding_cell_htlc_update_count);
		let mut holding_cell_held_htlc_flags: Vec<Option<()>> =
			Vec::with_capacity(holding_cell_htlc_update_count);
		let mut holding_cell_accountable_flags: Vec<bool> =
			Vec::with_capacity(holding_cell_htlc_update_count);
		// Vec of (htlc_id, failure_code, sha256_of_onion)
		let mut malformed_htlcs: Vec<(u64, u16, [u8; 32])> = Vec::new();
		(holding_cell_htlc_update_count as u64).write(writer)?;
		for update in self.context.holding_cell_htlc_updates.iter() {
			match update {
				&HTLCUpdateAwaitingACK::AddHTLC {
					ref amount_msat,
					ref cltv_expiry,
					ref payment_hash,
					ref source,
					ref onion_routing_packet,
					blinding_point,
					skimmed_fee_msat,
					hold_htlc,
					accountable,
				} => {
					0u8.write(writer)?;
					amount_msat.write(writer)?;
					cltv_expiry.write(writer)?;
					payment_hash.write(writer)?;
					source.write(writer)?;
					onion_routing_packet.write(writer)?;

					holding_cell_skimmed_fees.push(skimmed_fee_msat);
					holding_cell_blinding_points.push(blinding_point);
					holding_cell_held_htlc_flags.push(hold_htlc);
					holding_cell_accountable_flags.push(accountable);
				},
				&HTLCUpdateAwaitingACK::ClaimHTLC {
					ref payment_preimage,
					ref htlc_id,
					ref attribution_data,
				} => {
					1u8.write(writer)?;
					payment_preimage.write(writer)?;
					htlc_id.write(writer)?;

					// Store the attribution data for later writing.
					holding_cell_attribution_data.push(attribution_data.as_ref());
				},
				&HTLCUpdateAwaitingACK::FailHTLC { ref htlc_id, ref err_packet } => {
					2u8.write(writer)?;
					htlc_id.write(writer)?;
					err_packet.data.write(writer)?;

					// Store the attribution data for later writing.
					holding_cell_attribution_data.push(err_packet.attribution_data.as_ref());
				},
				&HTLCUpdateAwaitingACK::FailMalformedHTLC {
					htlc_id,
					failure_code,
					sha256_of_onion,
				} => {
					// We don't want to break downgrading by adding a new variant, so write a dummy
					// `::FailHTLC` variant and write the real malformed error as an optional TLV.
					malformed_htlcs.push((htlc_id, failure_code, sha256_of_onion));

					2u8.write(writer)?;
					htlc_id.write(writer)?;
					Vec::<u8>::new().write(writer)?;

					// Push 'None' attribution data for FailMalformedHTLC, because FailMalformedHTLC uses the same
					// type 2 and is deserialized as a FailHTLC.
					holding_cell_attribution_data.push(None);
				},
			}
		}

		match self.context.resend_order {
			RAACommitmentOrder::CommitmentFirst => 0u8.write(writer)?,
			RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
		}

		self.context.monitor_pending_channel_ready.write(writer)?;
		self.context.monitor_pending_revoke_and_ack.write(writer)?;
		self.context.monitor_pending_commitment_signed.write(writer)?;

		(self.context.monitor_pending_forwards.len() as u64).write(writer)?;
		for &(ref pending_forward, ref htlc_id) in self.context.monitor_pending_forwards.iter() {
			pending_forward.write(writer)?;
			htlc_id.write(writer)?;
		}

		(self.context.monitor_pending_failures.len() as u64).write(writer)?;
		for &(ref htlc_source, ref payment_hash, ref fail_reason) in
			self.context.monitor_pending_failures.iter()
		{
			htlc_source.write(writer)?;
			payment_hash.write(writer)?;
			fail_reason.write(writer)?;
		}

		if self.funding.is_outbound() {
			self.context.pending_update_fee.map(|(a, _)| a).write(writer)?;
		} else if let Some((feerate, FeeUpdateState::AwaitingRemoteRevokeToAnnounce)) =
			self.context.pending_update_fee
		{
			Some(feerate).write(writer)?;
		} else {
			// As for inbound HTLCs, if the update was only announced and never committed in a
			// commitment_signed, drop it.
			None::<u32>.write(writer)?;
		}
		self.context.holding_cell_update_fee.write(writer)?;

		self.context.next_holder_htlc_id.write(writer)?;
		(self.context.next_counterparty_htlc_id - dropped_inbound_htlcs).write(writer)?;
		self.context.update_time_counter.write(writer)?;
		self.context.feerate_per_kw.write(writer)?;

		// Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
		// however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
		// `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
		// consider the stale state on reload.
		0u8.write(writer)?;

		self.funding.funding_tx_confirmed_in.write(writer)?;
		self.funding.funding_tx_confirmation_height.write(writer)?;
		self.funding.short_channel_id.write(writer)?;

		self.context.counterparty_dust_limit_satoshis.write(writer)?;
		self.context.holder_dust_limit_satoshis.write(writer)?;
		self.context.counterparty_max_htlc_value_in_flight_msat.write(writer)?;

		// Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
		self.funding.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;

		self.context.counterparty_htlc_minimum_msat.write(writer)?;
		self.context.holder_htlc_minimum_msat.write(writer)?;
		self.context.counterparty_max_accepted_htlcs.write(writer)?;

		// Note that this field is ignored by 0.0.99+ as the TLV Optional variant is used instead.
		self.context.minimum_depth.unwrap_or(0).write(writer)?;

		match &self.context.counterparty_forwarding_info {
			Some(info) => {
				1u8.write(writer)?;
				info.fee_base_msat.write(writer)?;
				info.fee_proportional_millionths.write(writer)?;
				info.cltv_expiry_delta.write(writer)?;
			},
			None => 0u8.write(writer)?,
		}

		self.funding.channel_transaction_parameters.write(writer)?;
		self.funding.funding_transaction.write(writer)?;

		self.context.counterparty_next_commitment_point.write(writer)?;
		self.context.counterparty_current_commitment_point.write(writer)?;
		self.context.counterparty_node_id.write(writer)?;

		self.context.counterparty_shutdown_scriptpubkey.write(writer)?;

		self.context.commitment_secrets.write(writer)?;

		self.context.channel_update_status.write(writer)?;

		// If the channel type is something other than only-static-remote-key, then we need to have
		// older clients fail to deserialize this channel at all. If the type is
		// only-static-remote-key, we simply consider it "default" and don't write the channel type
		// out at all.
		let chan_type =
			if self.funding.get_channel_type() != &ChannelTypeFeatures::only_static_remote_key() {
				Some(self.funding.get_channel_type())
			} else {
				None
			};

		// The same logic applies for `holder_selected_channel_reserve_satoshis` values other than
		// the default, and when `holder_max_htlc_value_in_flight_msat` is configured to be set to
		// a different percentage of the channel value then 10%, which older versions of LDK used
		// to set it to before the percentage was made configurable.
		let legacy_reserve_satoshis = get_legacy_default_holder_selected_channel_reserve_satoshis(
			self.funding.get_value_satoshis(),
		);
		let serialized_holder_selected_reserve =
			if self.funding.holder_selected_channel_reserve_satoshis != legacy_reserve_satoshis {
				Some(self.funding.holder_selected_channel_reserve_satoshis)
			} else {
				None
			};

		let legacy_max_in_flight_msat = get_legacy_default_holder_max_htlc_value_in_flight_msat(
			self.funding.get_value_satoshis(),
		);
		let serialized_holder_htlc_max_in_flight =
			if self.context.holder_max_htlc_value_in_flight_msat != legacy_max_in_flight_msat {
				Some(self.context.holder_max_htlc_value_in_flight_msat)
			} else {
				None
			};

		let channel_pending_event_emitted = Some(self.context.channel_pending_event_emitted);
		let initial_channel_ready_event_emitted =
			Some(self.context.initial_channel_ready_event_emitted);
		let funding_tx_broadcast_safe_event_emitted =
			Some(self.context.funding_tx_broadcast_safe_event_emitted);

		// `user_id` used to be a single u64 value. In order to remain backwards compatible with
		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values. Therefore,
		// we write the high bytes as an option here.
		let user_id_high_opt = Some((self.context.user_id >> 64) as u64);

		let holder_max_accepted_htlcs =
			if self.context.holder_max_accepted_htlcs == DEFAULT_MAX_HTLCS {
				None
			} else {
				Some(self.context.holder_max_accepted_htlcs)
			};

		let mut monitor_pending_update_adds = None;
		if !self.context.monitor_pending_update_adds.is_empty() {
			monitor_pending_update_adds = Some(&self.context.monitor_pending_update_adds);
		}
		let is_manual_broadcast = Some(self.context.is_manual_broadcast);

		// We prevent downgrades from 0.3 only in the case where the holder-selected reserve
		// is 0, as we've had support for counterparty selected 0-reserves in prior
		// releases.
		let has_0reserve =
			(self.funding.holder_selected_channel_reserve_satoshis == 0).then_some(());
		let holder_commitment_point_previous_revoked =
			self.holder_commitment_point.previous_revoked_point();
		let holder_commitment_point_last_revoked =
			self.holder_commitment_point.last_revoked_point();
		let holder_commitment_point_current = self.holder_commitment_point.current_point();
		let holder_commitment_point_next = self.holder_commitment_point.next_point();
		let holder_commitment_point_pending_next = self.holder_commitment_point.pending_next_point;

		// Avoid writing any negotiations that are not at the signing stage yet, as they cannot be
		// resumed on reestablishment, but keep any already-negotiated candidates.
		let reset_funding_negotiation = self.should_reset_pending_splice_state(true);
		let should_persist_pending_splice =
			!reset_funding_negotiation || !self.negotiated_candidates().is_empty();
		let pending_splice = should_persist_pending_splice
			.then(|| ())
			.and_then(|_| self.pending_splice.as_ref())
			.map(|pending_funding| PendingFundingWriteable {
				pending_funding,
				reset_funding_negotiation,
			});

		let monitor_pending_tx_signatures =
			self.context.monitor_pending_tx_signatures.then_some(());

		write_tlv_fields!(writer, {
			(0, self.context.announcement_sigs, option),
			// minimum_depth and counterparty_selected_channel_reserve_satoshis used to have a
			// default value instead of being Option<>al. Thus, to maintain compatibility we write
			// them twice, once with their original default values above, and once as an option
			// here. On the read side, old versions will simply ignore the odd-type entries here,
			// and new versions map the default values to None and allow the TLV entries here to
			// override that.
			(1, self.context.minimum_depth, option),
			(2, chan_type, option), // We started writing the duplicative copy in channel_parameters
									// in 0.0.116, and support skipping writing this as of 0.3.
			(3, self.funding.counterparty_selected_channel_reserve_satoshis, option),
			(4, serialized_holder_selected_reserve, option),
			(5, self.context.config, required),
			(6, serialized_holder_htlc_max_in_flight, option),
			(7, self.context.shutdown_scriptpubkey, option),
			(8, self.context.blocked_monitor_updates, optional_vec),
			(9, self.context.target_closing_feerate_sats_per_kw, option),
			(10, monitor_pending_update_adds, option), // Added in 0.0.122
			(11, self.context.monitor_pending_finalized_fulfills, required_vec),
			(12, monitor_pending_tx_signatures, option), // Added in 0.3
			(13, self.context.channel_creation_height, required),
			(15, preimages, required_vec),
			(17, self.context.announcement_sigs_state, required),
			(19, self.context.latest_inbound_scid_alias, option),
			(21, self.context.outbound_scid_alias, required),
			(23, initial_channel_ready_event_emitted, option),
			(25, user_id_high_opt, option),
			(27, self.context.channel_keys_id, required),
			(28, holder_max_accepted_htlcs, option),
			(29, self.context.temporary_channel_id, option),
			(31, channel_pending_event_emitted, option),
			(35, pending_outbound_skimmed_fees, optional_vec),
			(37, holding_cell_skimmed_fees, optional_vec),
			(38, self.context.is_batch_funding, option),
			(39, pending_outbound_blinding_points, optional_vec),
			(41, holding_cell_blinding_points, optional_vec),
			(43, malformed_htlcs, optional_vec), // Added in 0.0.119
			(45, holder_commitment_point_next, required),
			(47, holder_commitment_point_pending_next, option),
			(49, self.context.local_initiated_shutdown, option), // Added in 0.0.122
			(51, is_manual_broadcast, option), // Added in 0.0.124
			(53, funding_tx_broadcast_safe_event_emitted, option), // Added in 0.0.124
			(55, removed_htlc_attribution_data, optional_vec), // Added in 0.2
			(57, holding_cell_attribution_data, optional_vec), // Added in 0.2
			(58, self.context.interactive_tx_signing_session, option), // Added in 0.2
			(59, self.funding.minimum_depth_override, option), // Added in 0.2
			(60, self.context.historical_scids, optional_vec), // Added in 0.2
			(61, fulfill_attribution_data, optional_vec), // Added in 0.2
			(63, holder_commitment_point_current, option), // Added in 0.2
			(64, pending_splice, option), // Added in 0.2
			// 65 was previously used for quiescent_action
			(67, pending_outbound_held_htlc_flags, optional_vec), // Added in 0.2
			(69, holding_cell_held_htlc_flags, optional_vec), // Added in 0.2
			(70, has_0reserve, option), // Added in 0.3 to prevent downgrades
			(71, holder_commitment_point_previous_revoked, option), // Added in 0.3
			(73, holder_commitment_point_last_revoked, option), // Added in 0.3
			(75, inbound_committed_update_adds, optional_vec),
			(77, holding_cell_accountable_flags, optional_vec), // Added in 0.3
			(79, pending_outbound_accountable, optional_vec), // Added in 0.3
		});

		Ok(())
	}
}

impl<'a, 'b, 'c, ES: EntropySource, SP: SignerProvider>
	ReadableArgs<(&'a ES, &'b SP, &'c ChannelTypeFeatures)> for FundedChannel<SP>
{
	fn read<R: io::Read>(
		reader: &mut R, args: (&'a ES, &'b SP, &'c ChannelTypeFeatures),
	) -> Result<Self, DecodeError> {
		let (entropy_source, signer_provider, our_supported_features) = args;
		let ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
		if ver <= 2 {
			return Err(DecodeError::UnknownVersion);
		}

		// `user_id` used to be a single u64 value. In order to remain backwards compatible with
		// versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We read
		// the low bytes now and the high bytes later.
		let user_id_low: u64 = Readable::read(reader)?;

		let mut config = LegacyChannelConfig::default();
		{
			// Read the 8 bytes of backwards-compatibility ChannelConfig data.
			let mut _val: u64 = Readable::read(reader)?;
		}

		let channel_id: ChannelId = Readable::read(reader)?;
		let channel_state = ChannelState::from_u32(Readable::read(reader)?)
			.map_err(|_| DecodeError::InvalidValue)?;
		let channel_value_satoshis = Readable::read(reader)?;

		let latest_monitor_update_id = Readable::read(reader)?;

		// Read the old serialization for shutdown_pubkey, preferring the TLV field later if set.
		let mut shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
			Ok(pubkey) => Some(ShutdownScript::new_p2wpkh_from_pubkey(pubkey)),
			Err(_) => None,
		};
		let destination_script = Readable::read(reader)?;

		let holder_commitment_next_transaction_number = Readable::read(reader)?;
		let counterparty_next_commitment_transaction_number = Readable::read(reader)?;
		let value_to_self_msat = Readable::read(reader)?;

		let pending_inbound_htlc_count: u64 = Readable::read(reader)?;

		let mut pending_inbound_htlcs = Vec::with_capacity(cmp::min(
			pending_inbound_htlc_count as usize,
			DEFAULT_MAX_HTLCS as usize,
		));
		for _ in 0..pending_inbound_htlc_count {
			pending_inbound_htlcs.push(InboundHTLCOutput {
				htlc_id: Readable::read(reader)?,
				amount_msat: Readable::read(reader)?,
				cltv_expiry: Readable::read(reader)?,
				payment_hash: Readable::read(reader)?,
				state: match <u8 as Readable>::read(reader)? {
					1 => {
						let resolution = if ver <= 3 {
							InboundHTLCResolution::Resolved {
								pending_htlc_status: Readable::read(reader)?,
							}
						} else {
							Readable::read(reader)?
						};
						InboundHTLCState::AwaitingRemoteRevokeToAnnounce(resolution)
					},
					2 => {
						let resolution = if ver <= 3 {
							InboundHTLCResolution::Resolved {
								pending_htlc_status: Readable::read(reader)?,
							}
						} else {
							Readable::read(reader)?
						};
						InboundHTLCState::AwaitingAnnouncedRemoteRevoke(resolution)
					},
					3 => InboundHTLCState::Committed { update_add_htlc: InboundUpdateAdd::Legacy },
					4 => {
						let reason = match <u8 as Readable>::read(reader)? {
							0 => InboundHTLCRemovalReason::FailRelay(msgs::OnionErrorPacket {
								data: Readable::read(reader)?,
								attribution_data: None,
							}),
							1 => {
								let (hash, code) = Readable::read(reader)?;
								InboundHTLCRemovalReason::FailMalformed {
									sha256_of_onion: hash,
									failure_code: code,
								}
							},
							2 => InboundHTLCRemovalReason::Fulfill {
								preimage: Readable::read(reader)?,
								attribution_data: None,
							},
							_ => return Err(DecodeError::InvalidValue),
						};
						InboundHTLCState::LocalRemoved(reason)
					},
					_ => return Err(DecodeError::InvalidValue),
				},
			});
		}

		let pending_outbound_htlc_count: u64 = Readable::read(reader)?;
		let mut pending_outbound_htlcs = Vec::with_capacity(cmp::min(
			pending_outbound_htlc_count as usize,
			DEFAULT_MAX_HTLCS as usize,
		));
		for _ in 0..pending_outbound_htlc_count {
			pending_outbound_htlcs.push(OutboundHTLCOutput {
				htlc_id: Readable::read(reader)?,
				amount_msat: Readable::read(reader)?,
				cltv_expiry: Readable::read(reader)?,
				payment_hash: Readable::read(reader)?,
				source: Readable::read(reader)?,
				state: match <u8 as Readable>::read(reader)? {
					0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
					1 => OutboundHTLCState::Committed,
					2 => {
						let option: Option<HTLCFailReason> = Readable::read(reader)?;
						let outcome = match option {
							Some(r) => OutboundHTLCOutcome::Failure(r),
							// Initialize this variant with a dummy preimage, the actual preimage will be filled in further down
							None => OutboundHTLCOutcome::Success {
								preimage: PaymentPreimage([0u8; 32]),
								attribution_data: None,
							},
						};
						OutboundHTLCState::RemoteRemoved(outcome)
					},
					3 => {
						let option: Option<HTLCFailReason> = Readable::read(reader)?;
						let outcome = match option {
							Some(r) => OutboundHTLCOutcome::Failure(r),
							// Initialize this variant with a dummy preimage, the actual preimage will be filled in further down
							None => OutboundHTLCOutcome::Success {
								preimage: PaymentPreimage([0u8; 32]),
								attribution_data: None,
							},
						};
						OutboundHTLCState::AwaitingRemoteRevokeToRemove(outcome)
					},
					4 => {
						let option: Option<HTLCFailReason> = Readable::read(reader)?;
						let outcome = match option {
							Some(r) => OutboundHTLCOutcome::Failure(r),
							// Initialize this variant with a dummy preimage, the actual preimage will be filled in further down
							None => OutboundHTLCOutcome::Success {
								preimage: PaymentPreimage([0u8; 32]),
								attribution_data: None,
							},
						};
						OutboundHTLCState::AwaitingRemovedRemoteRevoke(outcome)
					},
					_ => return Err(DecodeError::InvalidValue),
				},
				skimmed_fee_msat: None,
				blinding_point: None,
				send_timestamp: None,
				hold_htlc: None,
				accountable: false,
			});
		}

		let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
		let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(
			holding_cell_htlc_update_count as usize,
			DEFAULT_MAX_HTLCS as usize * 2,
		));
		for _ in 0..holding_cell_htlc_update_count {
			holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
				0 => HTLCUpdateAwaitingACK::AddHTLC {
					amount_msat: Readable::read(reader)?,
					cltv_expiry: Readable::read(reader)?,
					payment_hash: Readable::read(reader)?,
					source: Readable::read(reader)?,
					onion_routing_packet: Readable::read(reader)?,
					skimmed_fee_msat: None,
					blinding_point: None,
					hold_htlc: None,
					accountable: false,
				},
				1 => HTLCUpdateAwaitingACK::ClaimHTLC {
					payment_preimage: Readable::read(reader)?,
					htlc_id: Readable::read(reader)?,
					attribution_data: None,
				},
				2 => HTLCUpdateAwaitingACK::FailHTLC {
					htlc_id: Readable::read(reader)?,
					err_packet: OnionErrorPacket {
						data: Readable::read(reader)?,
						attribution_data: None,
					},
				},
				_ => return Err(DecodeError::InvalidValue),
			});
		}

		let resend_order = match <u8 as Readable>::read(reader)? {
			0 => RAACommitmentOrder::CommitmentFirst,
			1 => RAACommitmentOrder::RevokeAndACKFirst,
			_ => return Err(DecodeError::InvalidValue),
		};

		let monitor_pending_channel_ready = Readable::read(reader)?;
		let monitor_pending_revoke_and_ack = Readable::read(reader)?;
		let monitor_pending_commitment_signed = Readable::read(reader)?;

		let monitor_pending_forwards_count: u64 = Readable::read(reader)?;
		let mut monitor_pending_forwards = Vec::with_capacity(cmp::min(
			monitor_pending_forwards_count as usize,
			DEFAULT_MAX_HTLCS as usize,
		));
		for _ in 0..monitor_pending_forwards_count {
			monitor_pending_forwards.push((Readable::read(reader)?, Readable::read(reader)?));
		}

		let monitor_pending_failures_count: u64 = Readable::read(reader)?;
		let mut monitor_pending_failures = Vec::with_capacity(cmp::min(
			monitor_pending_failures_count as usize,
			DEFAULT_MAX_HTLCS as usize,
		));
		for _ in 0..monitor_pending_failures_count {
			monitor_pending_failures.push((
				Readable::read(reader)?,
				Readable::read(reader)?,
				Readable::read(reader)?,
			));
		}

		let pending_update_fee_value: Option<u32> = Readable::read(reader)?;

		let holding_cell_update_fee = Readable::read(reader)?;

		let next_holder_htlc_id = Readable::read(reader)?;
		let next_counterparty_htlc_id = Readable::read(reader)?;
		let update_time_counter = Readable::read(reader)?;
		let feerate_per_kw = Readable::read(reader)?;

		// Versions prior to 0.0.100 expected to read the fields of `last_sent_closing_fee` here,
		// however we are supposed to restart shutdown fee negotiation on reconnect (and wipe
		// `last_send_closing_fee` in `remove_uncommitted_htlcs_and_mark_paused`) so we should never
		// consider the stale state on reload.
		match <u8 as Readable>::read(reader)? {
			0 => {},
			1 => {
				let _: u32 = Readable::read(reader)?;
				let _: u64 = Readable::read(reader)?;
				let _: Signature = Readable::read(reader)?;
			},
			_ => return Err(DecodeError::InvalidValue),
		}

		let funding_tx_confirmed_in = Readable::read(reader)?;
		let funding_tx_confirmation_height = Readable::read(reader)?;
		let short_channel_id = Readable::read(reader)?;

		let counterparty_dust_limit_satoshis = Readable::read(reader)?;
		let holder_dust_limit_satoshis = Readable::read(reader)?;
		let counterparty_max_htlc_value_in_flight_msat = Readable::read(reader)?;
		let mut counterparty_selected_channel_reserve_satoshis = None;
		{
			// Read the 8 bytes of backwards-compatibility counterparty_selected_channel_reserve_satoshis data.
			let _dummy: u64 = Readable::read(reader)?;
		}
		let counterparty_htlc_minimum_msat = Readable::read(reader)?;
		let holder_htlc_minimum_msat = Readable::read(reader)?;
		let counterparty_max_accepted_htlcs = Readable::read(reader)?;

		let mut minimum_depth = None;
		{
			// Read the 4 bytes of backwards-compatibility minimum_depth data.
			let _dummy: u32 = Readable::read(reader)?;
		}

		let counterparty_forwarding_info = match <u8 as Readable>::read(reader)? {
			0 => None,
			1 => Some(CounterpartyForwardingInfo {
				fee_base_msat: Readable::read(reader)?,
				fee_proportional_millionths: Readable::read(reader)?,
				cltv_expiry_delta: Readable::read(reader)?,
			}),
			_ => return Err(DecodeError::InvalidValue),
		};

		let channel_parameters: ChannelTransactionParameters =
			ReadableArgs::<Option<u64>>::read(reader, Some(channel_value_satoshis))?;
		let funding_transaction: Option<Transaction> = Readable::read(reader)?;

		let counterparty_next_commitment_point = Readable::read(reader)?;

		let counterparty_current_commitment_point = Readable::read(reader)?;
		let counterparty_node_id = Readable::read(reader)?;

		let counterparty_shutdown_scriptpubkey = Readable::read(reader)?;
		let commitment_secrets = Readable::read(reader)?;

		let channel_update_status = Readable::read(reader)?;

		let pending_update_fee = if let Some(feerate) = pending_update_fee_value {
			Some((
				feerate,
				if channel_parameters.is_outbound_from_holder {
					FeeUpdateState::Outbound
				} else {
					FeeUpdateState::AwaitingRemoteRevokeToAnnounce
				},
			))
		} else {
			None
		};

		let mut announcement_sigs = None;
		let mut target_closing_feerate_sats_per_kw = None;
		let mut monitor_pending_finalized_fulfills = Some(Vec::new());
		let mut holder_selected_channel_reserve_satoshis = Some(
			get_legacy_default_holder_selected_channel_reserve_satoshis(channel_value_satoshis),
		);

		let mut holder_max_htlc_value_in_flight_msat =
			Some(get_legacy_default_holder_max_htlc_value_in_flight_msat(channel_value_satoshis));
		let mut channel_type = None;
		let mut channel_creation_height = 0u32;
		// Starting in 0.2, all the elements in this vector will be `Some`, but they are still
		// serialized as options to maintain backwards compatibility
		let mut preimages: Vec<Option<PaymentPreimage>> = Vec::new();
		let mut fulfill_attribution_data: Option<Vec<Option<AttributionData>>> = None;

		// If we read an old Channel, for simplicity we just treat it as "we never sent an
		// AnnouncementSignatures" which implies we'll re-send it on reconnect, but that's fine.
		let mut announcement_sigs_state = AnnouncementSigsState::NotSent;
		let mut latest_inbound_scid_alias = None;
		let mut outbound_scid_alias = 0u64;
		let mut channel_pending_event_emitted = None;
		let mut initial_channel_ready_event_emitted = None;
		let mut funding_tx_broadcast_safe_event_emitted = None;

		let mut user_id_high_opt: Option<u64> = None;
		let mut channel_keys_id = [0u8; 32];
		let mut temporary_channel_id: Option<ChannelId> = None;
		let mut holder_max_accepted_htlcs: Option<u16> = None;

		let mut blocked_monitor_updates = Some(Vec::new());

		let mut pending_outbound_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;
		let mut holding_cell_skimmed_fees_opt: Option<Vec<Option<u64>>> = None;

		let mut is_batch_funding: Option<()> = None;

		let mut local_initiated_shutdown: Option<()> = None;

		let mut pending_outbound_blinding_points_opt: Option<Vec<Option<PublicKey>>> = None;
		let mut holding_cell_blinding_points_opt: Option<Vec<Option<PublicKey>>> = None;

		let mut removed_htlc_attribution_data: Option<Vec<Option<AttributionData>>> = None;
		let mut holding_cell_attribution_data: Option<Vec<Option<AttributionData>>> = None;

		let mut malformed_htlcs: Option<Vec<(u64, u16, [u8; 32])>> = None;
		let mut monitor_pending_update_adds: Option<Vec<msgs::UpdateAddHTLC>> = None;

		let mut _has_0reserve: Option<()> = None;
		let mut holder_commitment_point_previous_revoked_opt: Option<PublicKey> = None;
		let mut holder_commitment_point_last_revoked_opt: Option<PublicKey> = None;
		let mut holder_commitment_point_current_opt: Option<PublicKey> = None;
		let mut holder_commitment_point_next_opt: Option<PublicKey> = None;
		let mut holder_commitment_point_pending_next_opt: Option<PublicKey> = None;
		let mut is_manual_broadcast = None;

		let mut historical_scids = Some(Vec::new());

		let mut interactive_tx_signing_session: Option<InteractiveTxSigningSession> = None;

		let mut minimum_depth_override: Option<u32> = None;

		let mut pending_splice: Option<PendingFunding> = None;

		let mut pending_outbound_held_htlc_flags_opt: Option<Vec<Option<()>>> = None;
		let mut holding_cell_held_htlc_flags_opt: Option<Vec<Option<()>>> = None;
		let mut inbound_committed_update_adds_opt: Option<Vec<InboundUpdateAdd>> = None;
		let mut holding_cell_accountable: Option<Vec<bool>> = None;
		let mut pending_outbound_accountable: Option<Vec<bool>> = None;

		let mut monitor_pending_tx_signatures: Option<()> = None;

		read_tlv_fields!(reader, {
			(0, announcement_sigs, option),
			(1, minimum_depth, option),
			(2, channel_type, option),
			(3, counterparty_selected_channel_reserve_satoshis, option),
			(4, holder_selected_channel_reserve_satoshis, option),
			(5, config, required),
			(6, holder_max_htlc_value_in_flight_msat, option),
			(7, shutdown_scriptpubkey, option),
			(8, blocked_monitor_updates, optional_vec),
			(9, target_closing_feerate_sats_per_kw, option),
			(10, monitor_pending_update_adds, option), // Added in 0.0.122
			(11, monitor_pending_finalized_fulfills, optional_vec),
			(12, monitor_pending_tx_signatures, option), // Added in 0.3
			(13, channel_creation_height, required),
			(15, preimages, required_vec), // The preimages transitioned from optional to required in 0.2
			(17, announcement_sigs_state, required),
			(19, latest_inbound_scid_alias, option),
			(21, outbound_scid_alias, required),
			(23, initial_channel_ready_event_emitted, option),
			(25, user_id_high_opt, option),
			(27, channel_keys_id, required),
			(28, holder_max_accepted_htlcs, option),
			(29, temporary_channel_id, option),
			(31, channel_pending_event_emitted, option),
			(35, pending_outbound_skimmed_fees_opt, optional_vec),
			(37, holding_cell_skimmed_fees_opt, optional_vec),
			(38, is_batch_funding, option),
			(39, pending_outbound_blinding_points_opt, optional_vec),
			(41, holding_cell_blinding_points_opt, optional_vec),
			(43, malformed_htlcs, optional_vec), // Added in 0.0.119
			(45, holder_commitment_point_next_opt, option),
			(47, holder_commitment_point_pending_next_opt, option),
			(49, local_initiated_shutdown, option),
			(51, is_manual_broadcast, option),
			(53, funding_tx_broadcast_safe_event_emitted, option),
			(55, removed_htlc_attribution_data, optional_vec), // Added in 0.2
			(57, holding_cell_attribution_data, optional_vec), // Added in 0.2
			(58, interactive_tx_signing_session, option), // Added in 0.2
			(59, minimum_depth_override, option), // Added in 0.2
			(60, historical_scids, optional_vec), // Added in 0.2
			(61, fulfill_attribution_data, optional_vec), // Added in 0.2
			(63, holder_commitment_point_current_opt, option), // Added in 0.2
			(64, pending_splice, option), // Added in 0.2
			// 65 quiescent_action: Added in 0.2; removed in 0.3
			(67, pending_outbound_held_htlc_flags_opt, optional_vec), // Added in 0.2
			(69, holding_cell_held_htlc_flags_opt, optional_vec), // Added in 0.2
			(70, _has_0reserve, option), // Added in 0.3 to prevent downgrades
			(71, holder_commitment_point_previous_revoked_opt, option), // Added in 0.3
			(73, holder_commitment_point_last_revoked_opt, option), // Added in 0.3
			(75, inbound_committed_update_adds_opt, optional_vec),
			(77, holding_cell_accountable, optional_vec), // Added in 0.3
			(79, pending_outbound_accountable, optional_vec), // Added in 0.3
		});

		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);

		let mut iter = preimages.into_iter();
		let mut fulfill_attribution_data_iter = fulfill_attribution_data.map(Vec::into_iter);
		for htlc in pending_outbound_htlcs.iter_mut() {
			match &mut htlc.state {
				OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success {
					ref mut preimage,
					ref mut attribution_data,
				})
				| OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success {
					ref mut preimage,
					ref mut attribution_data,
				}) => {
					// This variant was initialized like this further above
					debug_assert_eq!(preimage, &PaymentPreimage([0u8; 32]));
					// Flatten and unwrap the preimage; they are always set starting in 0.2.
					*preimage = iter.next().flatten().ok_or(DecodeError::InvalidValue)?;

					*attribution_data = fulfill_attribution_data_iter
						.as_mut()
						.and_then(Iterator::next)
						.ok_or(DecodeError::InvalidValue)?;
				},
				_ => {},
			}
		}
		// We expect all preimages to be consumed above
		if iter.next().is_some() {
			return Err(DecodeError::InvalidValue);
		}

		if let Some(channel_type) = channel_type {
			let chan_features = verify_channel_type_features(Some(channel_type), None)?;

			if chan_features != channel_parameters.channel_type_features {
				return Err(DecodeError::InvalidValue);
			}
		}
		let chan_type = &channel_parameters.channel_type_features;
		if chan_type.supports_any_optional_bits()
			|| chan_type.requires_unknown_bits_from(&our_supported_features)
		{
			// If the channel was written by a new version and negotiated with features we don't
			// understand yet, refuse to read it.
			return Err(DecodeError::UnknownRequiredFeature);
		}

		let mut secp_ctx = Secp256k1::new();
		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());

		// `user_id` used to be a single u64 value. In order to remain backwards
		// compatible with versions prior to 0.0.113, the u128 is serialized as two
		// separate u64 values.
		let user_id = user_id_low as u128 + ((user_id_high_opt.unwrap_or(0) as u128) << 64);

		let holder_max_accepted_htlcs = holder_max_accepted_htlcs.unwrap_or(DEFAULT_MAX_HTLCS);

		if let Some(skimmed_fees) = pending_outbound_skimmed_fees_opt {
			let mut iter = skimmed_fees.into_iter();
			for htlc in pending_outbound_htlcs.iter_mut() {
				htlc.skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
			}
			// We expect all skimmed fees to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(skimmed_fees) = holding_cell_skimmed_fees_opt {
			let mut iter = skimmed_fees.into_iter();
			for htlc in holding_cell_htlc_updates.iter_mut() {
				if let HTLCUpdateAwaitingACK::AddHTLC { ref mut skimmed_fee_msat, .. } = htlc {
					*skimmed_fee_msat = iter.next().ok_or(DecodeError::InvalidValue)?;
				}
			}
			// We expect all skimmed fees to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(blinding_pts) = pending_outbound_blinding_points_opt {
			let mut iter = blinding_pts.into_iter();
			for htlc in pending_outbound_htlcs.iter_mut() {
				htlc.blinding_point = iter.next().ok_or(DecodeError::InvalidValue)?;
			}
			// We expect all blinding points to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(blinding_pts) = holding_cell_blinding_points_opt {
			let mut iter = blinding_pts.into_iter();
			for htlc in holding_cell_htlc_updates.iter_mut() {
				if let HTLCUpdateAwaitingACK::AddHTLC { ref mut blinding_point, .. } = htlc {
					*blinding_point = iter.next().ok_or(DecodeError::InvalidValue)?;
				}
			}
			// We expect all blinding points to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(held_htlcs) = pending_outbound_held_htlc_flags_opt {
			let mut iter = held_htlcs.into_iter();
			for htlc in pending_outbound_htlcs.iter_mut() {
				htlc.hold_htlc = iter.next().ok_or(DecodeError::InvalidValue)?;
			}
			// We expect all held HTLC flags to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(held_htlcs) = holding_cell_held_htlc_flags_opt {
			let mut iter = held_htlcs.into_iter();
			for htlc in holding_cell_htlc_updates.iter_mut() {
				if let HTLCUpdateAwaitingACK::AddHTLC { ref mut hold_htlc, .. } = htlc {
					*hold_htlc = iter.next().ok_or(DecodeError::InvalidValue)?;
				}
			}
			// We expect all held HTLC flags to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(update_adds) = inbound_committed_update_adds_opt {
			let mut iter = update_adds.into_iter();
			for htlc in pending_inbound_htlcs.iter_mut() {
				if let InboundHTLCState::Committed { ref mut update_add_htlc } = htlc.state {
					*update_add_htlc = iter.next().ok_or(DecodeError::InvalidValue)?;
				}
			}
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}

		if let Some(accountable_htlcs) = holding_cell_accountable {
			let mut iter = accountable_htlcs.into_iter();
			for htlc in holding_cell_htlc_updates.iter_mut() {
				if let HTLCUpdateAwaitingACK::AddHTLC { ref mut accountable, .. } = htlc {
					*accountable = iter.next().ok_or(DecodeError::InvalidValue)?;
				}
			}
			// We expect all accountable HTLC signals to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(accountable_htlcs) = pending_outbound_accountable {
			let mut iter = accountable_htlcs.into_iter();
			for htlc in pending_outbound_htlcs.iter_mut() {
				htlc.accountable = iter.next().ok_or(DecodeError::InvalidValue)?;
			}
			// We expect all accountable HTLC signals to be consumed above
			if iter.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}
		if let Some(attribution_data_list) = removed_htlc_attribution_data {
			let mut removed_htlcs = pending_inbound_htlcs.iter_mut().filter_map(|status| {
				if let InboundHTLCState::LocalRemoved(reason) = &mut status.state {
					match reason {
						InboundHTLCRemovalReason::FailRelay(ref mut packet) => {
							Some(&mut packet.attribution_data)
						},
						InboundHTLCRemovalReason::Fulfill { ref mut attribution_data, .. } => {
							Some(attribution_data)
						},
						_ => None,
					}
				} else {
					None
				}
			});

			for attribution_data in attribution_data_list {
				*removed_htlcs.next().ok_or(DecodeError::InvalidValue)? = attribution_data;
			}
			if removed_htlcs.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}

		if let Some(attribution_data_list) = holding_cell_attribution_data {
			let mut holding_cell_htlcs =
				holding_cell_htlc_updates.iter_mut().filter_map(|upd| match upd {
					HTLCUpdateAwaitingACK::FailHTLC {
						err_packet: OnionErrorPacket { ref mut attribution_data, .. },
						..
					} => Some(attribution_data),
					HTLCUpdateAwaitingACK::ClaimHTLC { attribution_data, .. } => {
						Some(attribution_data)
					},
					_ => None,
				});

			for attribution_data in attribution_data_list {
				*holding_cell_htlcs.next().ok_or(DecodeError::InvalidValue)? = attribution_data;
			}
			if holding_cell_htlcs.next().is_some() {
				return Err(DecodeError::InvalidValue);
			}
		}

		if let Some(malformed_htlcs) = malformed_htlcs {
			for (malformed_htlc_id, failure_code, sha256_of_onion) in malformed_htlcs {
				let htlc_idx = holding_cell_htlc_updates
					.iter()
					.position(|htlc| {
						if let HTLCUpdateAwaitingACK::FailHTLC { htlc_id, err_packet } = htlc {
							let matches = *htlc_id == malformed_htlc_id;
							if matches {
								debug_assert!(err_packet.data.is_empty())
							}
							matches
						} else {
							false
						}
					})
					.ok_or(DecodeError::InvalidValue)?;
				let malformed_htlc = HTLCUpdateAwaitingACK::FailMalformedHTLC {
					htlc_id: malformed_htlc_id,
					failure_code,
					sha256_of_onion,
				};
				let _ =
					core::mem::replace(&mut holding_cell_htlc_updates[htlc_idx], malformed_htlc);
			}
		}

		// If we're restoring this channel for the first time after an upgrade, then we require that the
		// signer be available so that we can immediately populate the next commitment point. Channel
		// restoration will fail if this is not possible.
		let holder_commitment_point = {
			let current_point = holder_commitment_point_current_opt.or_else(|| {
				if holder_commitment_next_transaction_number == INITIAL_COMMITMENT_NUMBER {
					None
				} else {
					// If the current point is not available then splicing can't be initiated
					// until the next point is advanced and becomes the current point.
					holder_signer
						.get_per_commitment_point(
							holder_commitment_next_transaction_number + 1,
							&secp_ctx,
						)
						.ok()
				}
			});

			let previous_revoked_point =
				holder_commitment_point_previous_revoked_opt.or_else(|| {
					if holder_commitment_next_transaction_number > INITIAL_COMMITMENT_NUMBER - 3 {
						None
					} else {
						Some(holder_signer
						.get_per_commitment_point(
							holder_commitment_next_transaction_number + 3,
							&secp_ctx,
						)
						.expect("Must be able to derive the previous revoked commitment point upon channel restoration"))
					}
				});
			let last_revoked_point = holder_commitment_point_last_revoked_opt.or_else(|| {
				if holder_commitment_next_transaction_number > INITIAL_COMMITMENT_NUMBER - 2 {
					None
				} else {
					Some(holder_signer
						.get_per_commitment_point(
							holder_commitment_next_transaction_number + 2,
							&secp_ctx,
						)
						.expect("Must be able to derive the last revoked commitment point upon channel restoration"))
				}
			});

			match (holder_commitment_point_next_opt, holder_commitment_point_pending_next_opt) {
				(Some(next_point), pending_next_point) => HolderCommitmentPoint {
					next_transaction_number: holder_commitment_next_transaction_number,
					previous_revoked_point,
					last_revoked_point,
					current_point,
					next_point,
					pending_next_point,
				},
				(_, _) => {
					let next_point = holder_signer
						.get_per_commitment_point(holder_commitment_next_transaction_number, &secp_ctx)
						.expect(
							"Must be able to derive the next commitment point upon channel restoration",
						);
					let pending_next_point = holder_signer
						.get_per_commitment_point(
							holder_commitment_next_transaction_number - 1,
							&secp_ctx,
						)
						.expect(
							"Must be able to derive the pending next commitment point upon channel restoration",
						);
					HolderCommitmentPoint {
						next_transaction_number: holder_commitment_next_transaction_number,
						previous_revoked_point,
						last_revoked_point,
						current_point,
						next_point,
						pending_next_point: Some(pending_next_point),
					}
				},
			}
		};

		if let Some(funding_negotiation) = pending_splice
			.as_ref()
			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
		{
			if !matches!(funding_negotiation, FundingNegotiation::AwaitingSignatures { .. }) {
				return Err(DecodeError::InvalidValue);
			}
		}

		Ok(FundedChannel {
			funding: FundingScope {
				value_to_self_msat,
				counterparty_selected_channel_reserve_satoshis,
				holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis
					.unwrap(),

				#[cfg(debug_assertions)]
				holder_prev_commitment_tx_balance: Mutex::new((0, 0)),
				#[cfg(debug_assertions)]
				counterparty_prev_commitment_tx_balance: Mutex::new((0, 0)),

				#[cfg(any(test, fuzzing))]
				next_local_fee: Mutex::new(PredictedNextFee::default()),
				#[cfg(any(test, fuzzing))]
				next_remote_fee: Mutex::new(PredictedNextFee::default()),

				channel_transaction_parameters: channel_parameters,
				funding_transaction,
				funding_tx_confirmed_in,
				funding_tx_confirmation_height,
				short_channel_id,
				minimum_depth_override,
			},
			context: ChannelContext {
				user_id,

				config,

				prev_config: None,

				// Note that we don't care about serializing handshake limits as we only ever serialize
				// channel data after the handshake has completed.
				inbound_handshake_limits_override: None,

				channel_id,
				temporary_channel_id,
				channel_state,
				announcement_sigs_state,
				secp_ctx,

				latest_monitor_update_id,

				holder_signer,
				shutdown_scriptpubkey,
				destination_script,

				counterparty_next_commitment_transaction_number,

				holder_max_accepted_htlcs,
				pending_inbound_htlcs,
				pending_outbound_htlcs,
				holding_cell_htlc_updates,

				resend_order,

				monitor_pending_tx_signatures: monitor_pending_tx_signatures.is_some(),
				monitor_pending_channel_ready,
				monitor_pending_revoke_and_ack,
				monitor_pending_commitment_signed,
				monitor_pending_forwards,
				monitor_pending_failures,
				monitor_pending_finalized_fulfills: monitor_pending_finalized_fulfills.unwrap(),
				monitor_pending_update_adds: monitor_pending_update_adds.unwrap_or_default(),

				signer_pending_revoke_and_ack: false,
				signer_pending_commitment_update: false,
				signer_pending_funding: false,
				signer_pending_closing: false,
				signer_pending_channel_ready: false,
				signer_pending_stale_state_verification: None,

				pending_update_fee,
				holding_cell_update_fee,
				next_holder_htlc_id,
				next_counterparty_htlc_id,
				update_time_counter,
				feerate_per_kw,

				last_sent_closing_fee: None,
				last_received_closing_sig: None,
				pending_counterparty_closing_signed: None,
				expecting_peer_commitment_signed: false,
				closing_fee_limits: None,
				target_closing_feerate_sats_per_kw,

				channel_creation_height,

				counterparty_dust_limit_satoshis,
				holder_dust_limit_satoshis,
				counterparty_max_htlc_value_in_flight_msat,
				holder_max_htlc_value_in_flight_msat: holder_max_htlc_value_in_flight_msat.unwrap(),
				counterparty_htlc_minimum_msat,
				holder_htlc_minimum_msat,
				counterparty_max_accepted_htlcs,
				minimum_depth,

				counterparty_forwarding_info,

				is_batch_funding,

				counterparty_next_commitment_point,
				counterparty_current_commitment_point,
				counterparty_node_id,

				counterparty_shutdown_scriptpubkey,

				commitment_secrets,

				channel_update_status,
				closing_signed_in_flight: false,

				announcement_sigs,

				workaround_lnd_bug_4006: None,
				funding_locked_txid_sent_in_reestablish: None,
				sent_message_awaiting_response: None,

				latest_inbound_scid_alias,
				// Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
				outbound_scid_alias,
				historical_scids: historical_scids.unwrap(),

				funding_tx_broadcast_safe_event_emitted: funding_tx_broadcast_safe_event_emitted
					.unwrap_or(false),
				channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
				initial_channel_ready_event_emitted: initial_channel_ready_event_emitted
					.unwrap_or(true),

				channel_keys_id,

				local_initiated_shutdown,

				blocked_monitor_updates: blocked_monitor_updates.unwrap(),
				is_manual_broadcast: is_manual_broadcast.unwrap_or(false),

				interactive_tx_signing_session,
			},
			holder_commitment_point,
			pending_splice,
			quiescent_action: None,
		})
	}
}

fn duration_since_epoch() -> Option<Duration> {
	#[cfg(any(not(feature = "std"), fuzzing))]
	let now = None;

	#[cfg(all(feature = "std", not(fuzzing)))]
	let now = Some(
		std::time::SystemTime::now()
			.duration_since(std::time::SystemTime::UNIX_EPOCH)
			.expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH"),
	);

	now
}

/// Returns the time expressed in hold time units (1 unit = 100 ms) that has elapsed between send_timestamp and now. If
/// any of the arguments are `None`, returns `None`.
pub(crate) fn hold_time_since(send_timestamp: Option<Duration>) -> Option<u32> {
	send_timestamp.and_then(|t| {
		duration_since_epoch().map(|now| {
			let elapsed = now.saturating_sub(t).as_millis() / HOLD_TIME_UNIT_MILLIS;
			u32::try_from(elapsed).unwrap_or(u32::MAX)
		})
	})
}

#[cfg(test)]
mod tests {
	use crate::chain::chaininterface::LowerBoundedFeeEstimator;
	use crate::chain::transaction::OutPoint;
	use crate::chain::BlockLocator;
	use crate::ln::chan_utils::{self, commit_tx_fee_sat};
	use crate::ln::channel::{
		AwaitingChannelReadyFlags, ChannelState, FundedChannel, HTLCUpdateAwaitingACK,
		InboundHTLCOutput, InboundHTLCState, InboundUpdateAdd, InboundV1Channel,
		NextCommitmentView, OutboundHTLCOutput, OutboundHTLCState, OutboundV1Channel,
		WithChannelContext, MIN_THEIR_CHAN_RESERVE_SATOSHIS,
	};
	use crate::ln::channel_keys::{RevocationBasepoint, RevocationKey};
	use crate::ln::channelmanager::{self, HTLCSource, PaymentId, TrustedChannelFeatures};
	use crate::ln::msgs;
	use crate::ln::msgs::{ChannelUpdate, UnsignedChannelUpdate, MAX_VALUE_MSAT};
	use crate::ln::onion_utils::{AttributionData, LocalHTLCFailureReason};
	use crate::ln::script::ShutdownScript;
	use crate::prelude::*;
	use crate::routing::router::{Path, RouteHop};
	use crate::sign::tx_builder::HTLCAmountDirection;
	#[cfg(ldk_test_vectors)]
	use crate::sign::{ChannelSigner, EntropySource, InMemorySigner, SignerProvider};
	#[cfg(ldk_test_vectors)]
	use crate::sync::Mutex;
	#[cfg(ldk_test_vectors)]
	use crate::types::features::ChannelTypeFeatures;
	use crate::types::features::{ChannelFeatures, NodeFeatures};
	use crate::types::payment::{PaymentHash, PaymentPreimage};
	use crate::util::config::UserConfig;
	use crate::util::errors::APIError;
	use crate::util::ser::{ReadableArgs, Writeable};
	use crate::util::test_utils::{
		self, OnGetShutdownScriptpubkey, TestFeeEstimator, TestKeysInterface, TestLogger,
	};
	use bitcoin::amount::Amount;
	use bitcoin::constants::ChainHash;
	use bitcoin::hashes::sha256::Hash as Sha256;
	use bitcoin::hashes::Hash;
	use bitcoin::hex::FromHex;
	use bitcoin::locktime::absolute::LockTime;
	use bitcoin::network::Network;
	use bitcoin::script::Builder;
	use bitcoin::secp256k1::ffi::Signature as FFISignature;
	use bitcoin::secp256k1::{ecdsa::Signature, Secp256k1};
	use bitcoin::secp256k1::{PublicKey, SecretKey};
	use bitcoin::transaction::{Transaction, TxOut, Version};
	use bitcoin::{WitnessProgram, WitnessVersion};
	use std::cmp;

	fn dummy_inbound_update_add() -> InboundUpdateAdd {
		InboundUpdateAdd::Legacy
	}

	// Checks only fulfillments credit the peer for adds and fee increases before our acknowledgment.
	// Rejects overspending and completes the commitment exchange for the accepted updates.
	fn do_test_htlc_removal_credit_for_peer_updates_before_our_ack(
		fulfill: bool, update_fee: bool,
	) {
		use crate::events::HTLCHandlingFailureType;
		use crate::ln::functional_test_utils::*;
		use crate::ln::msgs::ChannelMessageHandler;
		use crate::ln::onion_utils::create_payment_onion;
		use crate::ln::outbound_payment::RecipientOnionFields;

		const NEW_FEERATE: u32 = 20_000;
		let chanmon_cfgs = create_chanmon_cfgs(2);
		let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
		let legacy_cfg = test_legacy_channel_config();
		let node_chanmgrs =
			create_node_chanmgrs(2, &node_cfgs, &[Some(legacy_cfg.clone()), Some(legacy_cfg)]);
		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
		let (_, _, channel_id, _) = if update_fee {
			create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 100_000, 90_000_000)
		} else {
			create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0)
		};
		let node_a_id = nodes[0].node.get_our_node_id();
		let node_b_id = nodes[1].node.get_our_node_id();
		let (route, payment_hash, payment_preimage, payment_secret) =
			get_route_and_payment_hash!(nodes[0], nodes[1], 10_000_000);
		let onion = RecipientOnionFields::secret_only(payment_secret, 10_000_000);
		nodes[0]
			.node
			.send_payment_with_route(route, payment_hash, onion, PaymentId(payment_hash.0))
			.unwrap();
		check_added_monitors(&nodes[0], 1);
		let send_event = SendEvent::from_node(&nodes[0]);
		nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]);
		do_commitment_signed_dance(&nodes[1], &nodes[0], &send_event.commitment_msg, false, false);
		expect_and_process_pending_htlcs(&nodes[1], false);
		expect_payment_claimable!(nodes[1], payment_hash, payment_secret, 10_000_000);

		let fee_estimator = LowerBoundedFeeEstimator::new(&chanmon_cfgs[0].fee_estimator);
		let assert_unaffordable = |updates: &msgs::CommitmentUpdate| {
			let per_peer_lock;
			let mut peer_state_lock;
			let channel =
				get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, channel_id)
					.as_funded_mut()
					.unwrap();
			if let Some(fee) = &updates.update_fee {
				assert_eq!(
					channel
						.context
						.validate_update_fee(&channel.funding, &fee_estimator, fee.feerate_per_kw)
						.unwrap_err()
						.to_string(),
					"Funding remote cannot afford proposed new fee"
				);
			} else {
				assert_eq!(
					channel
						.update_add_htlc(&updates.update_add_htlcs[0], &fee_estimator)
						.unwrap_err()
						.to_string(),
					"Remote HTLC add would overdraw remaining funds"
				);
			}
		};

		if !fulfill {
			nodes[1].node.fail_htlc_backwards(&payment_hash);
			expect_and_process_pending_htlcs_and_htlc_handling_failed(
				&nodes[1],
				&[HTLCHandlingFailureType::Receive { payment_hash }],
			);
			check_added_monitors(&nodes[1], 1);
			let mut updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
			assert_eq!(updates.update_fail_htlcs.len(), 1);

			// A failure returns the payment to us, so it cannot fund either peer update.
			if update_fee {
				updates.update_fee =
					Some(msgs::UpdateFee { channel_id, feerate_per_kw: NEW_FEERATE });
			} else {
				let mut add = send_event.msgs[0].clone();
				add.amount_msat = 5_000_000;
				updates.update_add_htlcs.push(add);
			}
			assert_unaffordable(&updates);
			nodes[0].node.handle_update_fail_htlc(node_b_id, &updates.update_fail_htlcs[0]);
			assert_unaffordable(&updates);
			return;
		}

		let (_, peer_payment_hash, peer_payment_secret) =
			get_payment_preimage_hash(&nodes[0], Some(5_000_000), None);

		// Stage the peer's next update directly so claim_funds batches it with the fulfillment.
		// The update is affordable only after accounting for the fulfillment's credit.
		if update_fee {
			let per_peer_lock;
			let mut peer_state_lock;
			let channel =
				get_channel_ref!(nodes[1], nodes[0], per_peer_lock, peer_state_lock, channel_id)
					.as_funded_mut()
					.unwrap();
			let fee_msat =
				commit_tx_fee_sat(NEW_FEERATE, 0, channel.funding.get_channel_type()) * 1000;
			assert!(fee_msat > channel.funding.value_to_self_msat);
			channel.context.pending_update_fee =
				Some((NEW_FEERATE, super::FeeUpdateState::Outbound));
		} else {
			let mut htlc = {
				let per_peer_lock;
				let mut peer_state_lock;
				let channel = get_channel_ref!(
					nodes[0],
					nodes[1],
					per_peer_lock,
					peer_state_lock,
					channel_id
				)
				.as_funded()
				.unwrap();
				channel.context.pending_outbound_htlcs[0].clone()
			};
			htlc.amount_msat = 5_000_000;
			htlc.payment_hash = peer_payment_hash;
			if let HTLCSource::OutboundRoute {
				path,
				session_priv,
				first_hop_htlc_msat,
				payment_id,
				..
			} = &mut htlc.source
			{
				path.hops[0].pubkey = node_a_id;
				path.hops[0].fee_msat = htlc.amount_msat;
				*first_hop_htlc_msat = htlc.amount_msat;
				*payment_id = PaymentId(htlc.payment_hash.0);
				let onion =
					RecipientOnionFields::secret_only(peer_payment_secret, htlc.amount_msat);
				let (onion_packet, _, cltv_expiry) = create_payment_onion(
					&Secp256k1::new(),
					path,
					session_priv,
					&onion,
					nodes[1].best_block_info().1 + 1,
					&htlc.payment_hash,
					&None,
					None,
					[0; 32],
				)
				.unwrap();
				htlc.cltv_expiry = cltv_expiry;
				htlc.state = OutboundHTLCState::LocalAnnounced(Box::new(onion_packet));
			} else {
				unreachable!();
			}
			let per_peer_lock;
			let mut peer_state_lock;
			let channel =
				get_channel_ref!(nodes[1], nodes[0], per_peer_lock, peer_state_lock, channel_id)
					.as_funded_mut()
					.unwrap();
			assert_eq!(channel.context.next_holder_htlc_id, htlc.htlc_id);
			channel.context.next_holder_htlc_id += 1;
			channel.context.pending_outbound_htlcs.push(htlc);
		}

		nodes[1].node.claim_funds(payment_preimage);
		expect_payment_claimed!(nodes[1], payment_hash, 10_000_000);
		check_added_monitors(&nodes[1], 1);
		let updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
		assert_eq!(updates.update_fulfill_htlcs.len(), 1);
		assert_eq!(updates.update_add_htlcs.len(), if update_fee { 0 } else { 1 });
		assert_eq!(updates.update_fee.is_some(), update_fee);
		assert_unaffordable(&updates);

		nodes[0]
			.node
			.handle_update_fulfill_htlc(node_b_id, updates.update_fulfill_htlcs[0].clone());
		let mut overspend = updates.clone();
		if let Some(fee) = &mut overspend.update_fee {
			assert_eq!(fee.feerate_per_kw, NEW_FEERATE);
			nodes[0].node.handle_update_fee(node_b_id, fee);
			fee.feerate_per_kw = 30_000;
		} else {
			let add = &mut overspend.update_add_htlcs[0];
			nodes[0].node.handle_update_add_htlc(node_b_id, add);
			add.htlc_id += 1;
			add.amount_msat = 5_000_001;
		}
		assert_unaffordable(&overspend);

		do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
		expect_payment_sent!(nodes[0], payment_preimage, Some(0));
		if !update_fee {
			expect_and_process_pending_htlcs(&nodes[0], false);
			expect_payment_claimable!(nodes[0], peer_payment_hash, peer_payment_secret, 5_000_000);
			check_added_monitors(&nodes[0], 0);
		}
		for (local, remote) in [(0, 1), (1, 0)] {
			let per_peer_lock;
			let mut peer_state_lock;
			let channel = get_channel_ref!(
				nodes[local],
				nodes[remote],
				per_peer_lock,
				peer_state_lock,
				channel_id
			)
			.as_funded()
			.unwrap();
			if update_fee {
				assert_eq!(channel.context.feerate_per_kw, NEW_FEERATE);
				assert!(channel.context.pending_inbound_htlcs.is_empty());
				assert!(channel.context.pending_outbound_htlcs.is_empty());
			} else if local == 0 {
				assert!(channel.context.pending_outbound_htlcs.is_empty());
				assert_eq!(channel.context.pending_inbound_htlcs.len(), 1);
				assert!(matches!(
					channel.context.pending_inbound_htlcs[0].state,
					InboundHTLCState::Committed { .. }
				));
			} else {
				assert!(channel.context.pending_inbound_htlcs.is_empty());
				assert_eq!(channel.context.pending_outbound_htlcs.len(), 1);
				assert!(matches!(
					channel.context.pending_outbound_htlcs[0].state,
					OutboundHTLCState::Committed
				));
			}
		}
	}

	#[test]
	fn test_peer_update_fail_htlc_does_not_fund_peer_updates() {
		do_test_htlc_removal_credit_for_peer_updates_before_our_ack(false, false);
		do_test_htlc_removal_credit_for_peer_updates_before_our_ack(false, true);
	}

	#[test]
	fn test_update_fulfill_htlc_frees_liquidity_for_peer_updates_before_our_ack() {
		do_test_htlc_removal_credit_for_peer_updates_before_our_ack(true, false);
		do_test_htlc_removal_credit_for_peer_updates_before_our_ack(true, true);
	}

	#[test]
	#[rustfmt::skip]
	fn test_channel_state_order() {
		use crate::ln::channel::NegotiatingFundingFlags;
		use crate::ln::channel::FundingNegotiatedFlags;
		use crate::ln::channel::AwaitingChannelReadyFlags;
		use crate::ln::channel::ChannelReadyFlags;

		assert!(ChannelState::NegotiatingFunding(NegotiatingFundingFlags::new()) < ChannelState::FundingNegotiated(FundingNegotiatedFlags::new()));
		assert!(ChannelState::FundingNegotiated(FundingNegotiatedFlags::new()) < ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()));
		assert!(ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::new()) < ChannelState::ChannelReady(ChannelReadyFlags::new()));
		assert!(ChannelState::ChannelReady(ChannelReadyFlags::new()) < ChannelState::ShutdownComplete);
	}

	#[cfg(ldk_test_vectors)]
	struct Keys {
		signer: crate::sign::InMemorySigner,
	}

	#[cfg(ldk_test_vectors)]
	impl EntropySource for Keys {
		fn get_secure_random_bytes(&self) -> [u8; 32] {
			[0; 32]
		}
	}

	#[cfg(ldk_test_vectors)]
	impl SignerProvider for Keys {
		type EcdsaSigner = InMemorySigner;

		fn generate_channel_keys_id(&self, _inbound: bool, _user_channel_id: u128) -> [u8; 32] {
			self.signer.channel_keys_id()
		}

		fn derive_channel_signer(&self, _channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
			self.signer.clone()
		}

		fn get_destination_script(
			&self, _channel_keys_id: [u8; 32],
		) -> Result<bitcoin::script::ScriptBuf, ()> {
			let secp_ctx = Secp256k1::signing_only();
			let hex = "0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
			let channel_monitor_claim_key =
				SecretKey::from_slice(&<Vec<u8>>::from_hex(hex).unwrap()[..]).unwrap();
			let channel_monitor_claim_key_hash = bitcoin::WPubkeyHash::hash(
				&PublicKey::from_secret_key(&secp_ctx, &channel_monitor_claim_key).serialize(),
			);
			Ok(Builder::new()
				.push_opcode(bitcoin::opcodes::all::OP_PUSHBYTES_0)
				.push_slice(channel_monitor_claim_key_hash)
				.into_script())
		}

		fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()> {
			let secp_ctx = Secp256k1::signing_only();
			let hex = "0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
			let channel_close_key =
				SecretKey::from_slice(&<Vec<u8>>::from_hex(hex).unwrap()[..]).unwrap();
			Ok(ShutdownScript::new_p2wpkh_from_pubkey(PublicKey::from_secret_key(
				&secp_ctx,
				&channel_close_key,
			)))
		}
	}

	#[test]
	fn upfront_shutdown_script_incompatibility() {
		let mut features = channelmanager::provided_init_features(&UserConfig::default());
		features.clear_shutdown_anysegwit();
		let non_v0_segwit_shutdown_script = ShutdownScript::new_witness_program(
			&WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(),
		)
		.unwrap();

		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		keys_provider
			.expect(OnGetShutdownScriptpubkey { returns: non_v0_segwit_shutdown_script.clone() });
		let fee_estimator = TestFeeEstimator::new(253);
		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_estimator);
		let logger = TestLogger::new();

		let secp_ctx = Secp256k1::new();
		let node_id =
			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let config = UserConfig::default();
		let res = OutboundV1Channel::new(
			&bounded_fee_estimator,
			&&keys_provider,
			&&keys_provider,
			node_id,
			&features,
			10000000,
			100000,
			42,
			&config,
			0,
			42,
			None,
			&logger,
			None,
		);
		match res {
			Err(APIError::IncompatibleShutdownScript { script }) => {
				assert_eq!(script.into_inner(), non_v0_segwit_shutdown_script.into_inner());
			},
			Err(e) => panic!("Unexpected error: {:?}", e),
			Ok(_) => panic!("Expected error"),
		}
	}

	// Check that, during channel creation, we use the same feerate in the open channel message
	// as we do in the Channel object creation itself.
	#[test]
	#[rustfmt::skip]
	fn test_open_channel_msg_fee() {
		let original_fee = 253;
		let fee_est = TestFeeEstimator::new(original_fee);
		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&fee_est);
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		let logger = TestLogger::new();

		let node_a_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let config = UserConfig::default();
		let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&bounded_fee_estimator, &&keys_provider, &&keys_provider, node_a_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger, None).unwrap();

		// Now change the fee so we can check that the fee in the open_channel message is the
		// same as the old fee.
		*fee_est.sat_per_kw.lock().unwrap() = 500;
		let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
		assert_eq!(open_channel_msg.common_fields.commitment_feerate_sat_per_1000_weight, original_fee);
	}

	#[test]
	#[rustfmt::skip]
	fn test_holder_vs_counterparty_dust_limit() {
		// Test that when calculating the local and remote commitment transaction fees, the correct
		// dust limits are used.
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		let logger = TestLogger::new();
		let best_block = BlockLocator::from_network(network);

		// Go through the flow of opening a channel between two nodes, making sure
		// they have different dust limits.

		// Create Node A's channel pointing to Node B's pubkey
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let mut config = UserConfig::default();
		config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = false;
		let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 100_000_000, 42, &config, 0, 42, None, &logger, None).unwrap();

		// Create Node B's channel by receiving Node A's open_channel message
		// Make sure A's dust limit is as we expect.
		let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
		let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, None).unwrap();

		// Node B --> Node A: accept channel, explicitly setting B's dust limit.
		let mut accept_channel_msg = node_b_chan.accept_inbound_channel(&&logger).unwrap();
		accept_channel_msg.common_fields.dust_limit_satoshis = 546;
		node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
		node_a_chan.context.holder_dust_limit_satoshis = 1560;

		// Node A --> Node B: funding created
		let output_script = node_a_chan.funding.get_funding_redeemscript();
		let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
			value: Amount::from_sat(10000000), script_pubkey: output_script.clone(),
		}]};
		let funding_outpoint = OutPoint{ txid: tx.compute_txid(), index: 0 };
		let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
		let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();

		// Node B --> Node A: funding signed
		let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
		let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };

		// Put some inbound and outbound HTLCs in A's channel.
		let htlc_amount_msat = 11_092_000; // put an amount below A's effective dust limit but above B's.
		node_a_chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 0,
			amount_msat: htlc_amount_msat,
			payment_hash: PaymentHash(Sha256::hash(&[42; 32]).to_byte_array()),
			cltv_expiry: 300000000,
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add()  },
		});

		node_a_chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: 1,
			amount_msat: htlc_amount_msat, // put an amount below A's dust amount but above B's.
			payment_hash: PaymentHash(Sha256::hash(&[43; 32]).to_byte_array()),
			cltv_expiry: 200000000,
			state: OutboundHTLCState::Committed,
			source: HTLCSource::OutboundRoute {
				path: Path { hops: Vec::new(), blinded_tail: None },
				session_priv: SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
				first_hop_htlc_msat: 548,
				payment_id: PaymentId([42; 32]),
				bolt12_invoice: None,
			},
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		});

		// Make sure when Node A calculates their local commitment transaction, none of the HTLCs pass
		// the dust limit check.
		let htlc_candidate = HTLCAmountDirection { amount_msat: htlc_amount_msat, outbound: true };
		let local_commit_tx_fee = node_a_chan.context.get_next_local_commitment_stats(&node_a_chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, node_a_chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		let local_commit_fee_0_htlcs = commit_tx_fee_sat(node_a_chan.context.feerate_per_kw, 0, node_a_chan.funding.get_channel_type()) * 1000;
		assert_eq!(local_commit_tx_fee, local_commit_fee_0_htlcs);

		// Finally, make sure that when Node A calculates the remote's commitment transaction fees, all
		// of the HTLCs are seen to be above the dust limit.
		node_a_chan.funding.channel_transaction_parameters.is_outbound_from_holder = false;
		let remote_commit_fee_3_htlcs = commit_tx_fee_sat(node_a_chan.context.feerate_per_kw, 3, node_a_chan.funding.get_channel_type()) * 1000;
		let htlc_candidate = HTLCAmountDirection { amount_msat: htlc_amount_msat, outbound: true };
		let remote_commit_tx_fee = node_a_chan.context.get_next_remote_commitment_stats(&node_a_chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, node_a_chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		assert_eq!(remote_commit_tx_fee, remote_commit_fee_3_htlcs);
	}

	#[test]
	#[rustfmt::skip]
	fn test_timeout_vs_success_htlc_dust_limit() {
		// Make sure that when `get_next_local/remote_commitment_stats`
		// calculate the real dust limits for HTLCs (i.e. the dust limit given by the counterparty
		// *plus* the fees paid for the HTLC) they don't swap `HTLC_SUCCESS_TX_WEIGHT` for
		// `HTLC_TIMEOUT_TX_WEIGHT`, and vice versa.
		let test_est = TestFeeEstimator::new(253);
		let fee_est = LowerBoundedFeeEstimator::new(&test_est);
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		let logger = TestLogger::new();

		let node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let mut config = UserConfig::default();
		config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = false;
		let mut chan = OutboundV1Channel::<&TestKeysInterface>::new(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10_000_000, 100_000_000, 42, &config, 0, 42, None, &logger, None).unwrap();
		chan.context.counterparty_max_htlc_value_in_flight_msat = 1_000_000_000;

		let commitment_tx_fee_0_htlcs = commit_tx_fee_sat(chan.context.feerate_per_kw, 0, chan.funding.get_channel_type()) * 1000;
		let commitment_tx_fee_1_htlc = commit_tx_fee_sat(chan.context.feerate_per_kw, 1, chan.funding.get_channel_type()) * 1000;
		let (htlc_success_tx_fee_sat, htlc_timeout_tx_fee_sat) = chan_utils::second_stage_tx_fees_sat(
			&chan.funding.get_channel_type(), 253
		);

		// If HTLC_SUCCESS_TX_WEIGHT and HTLC_TIMEOUT_TX_WEIGHT were swapped: then this HTLC would be
		// counted as dust when it shouldn't be.
		let htlc_amt_above_timeout = (htlc_timeout_tx_fee_sat + chan.context.holder_dust_limit_satoshis + 1) * 1000;
		let htlc_candidate = HTLCAmountDirection { amount_msat: htlc_amt_above_timeout, outbound: true };
		let commitment_tx_fee = chan.context.get_next_local_commitment_stats(&chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);

		// If swapped: this HTLC would be counted as non-dust when it shouldn't be.
		let dust_htlc_amt_below_success = (htlc_success_tx_fee_sat + chan.context.holder_dust_limit_satoshis - 1) * 1000;
		let htlc_candidate = HTLCAmountDirection { amount_msat: dust_htlc_amt_below_success, outbound: false };
		let commitment_tx_fee = chan.context.get_next_local_commitment_stats(&chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);

		chan.funding.channel_transaction_parameters.is_outbound_from_holder = false;

		// If swapped: this HTLC would be counted as non-dust when it shouldn't be.
		let dust_htlc_amt_above_timeout = (htlc_timeout_tx_fee_sat + chan.context.counterparty_dust_limit_satoshis + 1) * 1000;
		let htlc_candidate = HTLCAmountDirection { amount_msat: dust_htlc_amt_above_timeout, outbound: true };
		let commitment_tx_fee = chan.context.get_next_remote_commitment_stats(&chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);

		// If swapped: this HTLC would be counted as dust when it shouldn't be.
		let htlc_amt_below_success = (htlc_success_tx_fee_sat + chan.context.counterparty_dust_limit_satoshis - 1) * 1000;
		let htlc_candidate = HTLCAmountDirection { amount_msat: htlc_amt_below_success, outbound: false };
		let commitment_tx_fee = chan.context.get_next_remote_commitment_stats(&chan.funding, Some(htlc_candidate), NextCommitmentView::ValidatingOwnUpdate, 0, chan.context.feerate_per_kw, false, None).unwrap().0.commitment_stats.commit_tx_fee_sat * 1000;
		assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
	}

	#[test]
	#[rustfmt::skip]
	fn channel_reestablish_no_updates() {
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let logger = TestLogger::new();
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let best_block = BlockLocator::from_network(network);
		let chain_hash = ChainHash::using_genesis_block(network);
		let keys_provider = TestKeysInterface::new(&seed, network);

		// Go through the flow of opening a channel between two nodes.

		// Create Node A's channel pointing to Node B's pubkey
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let config = UserConfig::default();
		let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger, None).unwrap();

		// Create Node B's channel by receiving Node A's open_channel message
		let open_channel_msg = node_a_chan.get_open_channel(chain_hash, &&logger).unwrap();
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
		let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, None).unwrap();

		// Node B --> Node A: accept channel
		let accept_channel_msg = node_b_chan.accept_inbound_channel(&&logger).unwrap();
		node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();

		// Node A --> Node B: funding created
		let output_script = node_a_chan.funding.get_funding_redeemscript();
		let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
			value: Amount::from_sat(10000000), script_pubkey: output_script.clone(),
		}]};
		let funding_outpoint = OutPoint{ txid: tx.compute_txid(), index: 0 };
		let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
		let (mut node_b_chan, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();

		// Node B --> Node A: funding signed
		let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
		let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };

		// Now disconnect the two nodes and check that the commitment point in
		// Node B's channel_reestablish message is sane.
		assert!(node_b_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger).is_ok());
		let msg = node_b_chan.get_channel_reestablish(&&logger);
		assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
		assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
		assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);

		// Check that the commitment point in Node A's channel_reestablish message
		// is sane.
		assert!(node_a_chan.remove_uncommitted_htlcs_and_mark_paused(&&logger).is_ok());
		let msg = node_a_chan.get_channel_reestablish(&&logger);
		assert_eq!(msg.next_local_commitment_number, 1); // now called next_commitment_number
		assert_eq!(msg.next_remote_commitment_number, 0); // now called next_revocation_number
		assert_eq!(msg.your_last_per_commitment_secret, [0; 32]);
	}

	#[test]
	fn test_configured_holder_max_htlc_value_in_flight() {
		do_test_configured_holder_max_htlc_value_in_flight(true);
		do_test_configured_holder_max_htlc_value_in_flight(false);
	}

	#[rustfmt::skip]
	fn do_test_configured_holder_max_htlc_value_in_flight(announce_channel: bool) {
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let logger = TestLogger::new();
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());

		let mut config_2_percent = UserConfig::default();
		config_2_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
		if announce_channel {
			config_2_percent
				.channel_handshake_config
				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 2;
		} else {
			config_2_percent
				.channel_handshake_config
				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 2;
		}
		let mut config_99_percent = UserConfig::default();
		config_99_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
		if announce_channel {
			config_99_percent
				.channel_handshake_config
				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 99;
		} else {
			config_99_percent
				.channel_handshake_config
				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 99;
		}
		let mut config_0_percent = UserConfig::default();
		config_0_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
		if announce_channel {
			config_0_percent
				.channel_handshake_config
				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 0;
		} else {
			config_0_percent
				.channel_handshake_config
				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 0;
		}
		let mut config_101_percent = UserConfig::default();
		config_101_percent.channel_handshake_config.announce_for_forwarding = announce_channel;
		if announce_channel {
			config_101_percent
				.channel_handshake_config
				.announced_channel_max_inbound_htlc_value_in_flight_percentage = 101;
		} else {
			config_101_percent
				.channel_handshake_config
				.unannounced_channel_max_inbound_htlc_value_in_flight_percentage = 101;
		}

		// Test that `OutboundV1Channel::new` creates a channel with the correct value for
		// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
		// which is set to the lower bound + 1 (2%) of the `channel_value`.
		let mut chan_1 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42, None, &logger, None).unwrap();
		let chan_1_value_msat = chan_1.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_1.context.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);

		// Test with the upper bound - 1 of valid values (99%).
		let chan_2 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42, None, &logger, None).unwrap();
		let chan_2_value_msat = chan_2.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_2.context.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);

		let chan_1_open_channel_msg = chan_1.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();

		// Test that `InboundV1Channel::new` creates a channel with the correct value for
		// `holder_max_htlc_value_in_flight_msat`, when configured with a valid percentage value,
		// which is set to the lower bound - 1 (2%) of the `channel_value`.
		let chan_3 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_2_percent), &channelmanager::provided_init_features(&config_2_percent), &chan_1_open_channel_msg, 7, &config_2_percent, 0, &&logger, None).unwrap();
		let chan_3_value_msat = chan_3.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_3.context.holder_max_htlc_value_in_flight_msat, (chan_3_value_msat as f64 * 0.02) as u64);

		// Test with the upper bound - 1 of valid values (99%).
		let chan_4 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_99_percent), &channelmanager::provided_init_features(&config_99_percent), &chan_1_open_channel_msg, 7, &config_99_percent, 0, &&logger, None).unwrap();
		let chan_4_value_msat = chan_4.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_4.context.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);

		// Test that `OutboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
		// if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a value less than 1.
		let chan_5 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42, None, &logger, None).unwrap();
		let chan_5_value_msat = chan_5.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_5.context.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);

		// Test that `OutboundV1Channel::new` uses the upper bound of the configurable percentage values
		// (100%) if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a larger value
		// than 100.
		let chan_6 = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42, None, &logger, None).unwrap();
		let chan_6_value_msat = chan_6.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);

		// Test that `InboundV1Channel::new` uses the lower bound of the configurable percentage values (1%)
		// if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a value less than 1.
		let chan_7 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_0_percent), &channelmanager::provided_init_features(&config_0_percent), &chan_1_open_channel_msg, 7, &config_0_percent, 0, &&logger, None).unwrap();
		let chan_7_value_msat = chan_7.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_7.context.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);

		// Test that `InboundV1Channel::new` uses the upper bound of the configurable percentage values
		// (100%) if `(un)announced_channel_max_inbound_htlc_value_in_flight_percentage` is set to a larger value
		// than 100.
		let chan_8 = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_101_percent), &channelmanager::provided_init_features(&config_101_percent), &chan_1_open_channel_msg, 7, &config_101_percent, 0, &&logger, None).unwrap();
		let chan_8_value_msat = chan_8.funding.get_value_satoshis() * 1000;
		assert_eq!(chan_8.context.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
	}

	#[test]
	#[rustfmt::skip]
	fn test_configured_holder_selected_channel_reserve_satoshis() {

		// Test that `OutboundV1Channel::new` and `InboundV1Channel::new` create a channel with the correct
		// channel reserves, when `their_channel_reserve_proportional_millionths` is configured.
		test_self_and_counterparty_channel_reserve(10_000_000, 0.02, 0.02);

		// Test with valid but unreasonably high channel reserves
		// Requesting and accepting parties have requested for 49%-49% and 60%-30% channel reserve
		test_self_and_counterparty_channel_reserve(10_000_000, 0.49, 0.49);
		test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.30);

		// Test with calculated channel reserve less than lower bound
		// i.e `MIN_THEIR_CHAN_RESERVE_SATOSHIS`
		test_self_and_counterparty_channel_reserve(100_000, 0.00002, 0.30);

		// Test with invalid channel reserves since sum of both is greater than or equal
		// to channel value
		test_self_and_counterparty_channel_reserve(10_000_000, 0.50, 0.50);
		test_self_and_counterparty_channel_reserve(10_000_000, 0.60, 0.50);

		// Make sure we correctly handle reserves greater than the channel value
		test_self_and_counterparty_channel_reserve(100_000, 1.1, 0.30);
		test_self_and_counterparty_channel_reserve(100_000, 0.30, 1.1);
	}

	#[rustfmt::skip]
	fn test_self_and_counterparty_channel_reserve(channel_value_satoshis: u64, outbound_selected_channel_reserve_perc: f64, inbound_selected_channel_reserve_perc: f64) {
		let test_est = TestFeeEstimator::new(15000);
		let fee_est = LowerBoundedFeeEstimator::new(&test_est);
		let logger = TestLogger::new();
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let keys_provider = TestKeysInterface::new(&seed, network);
		let outbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let inbound_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());


		let mut outbound_node_config = UserConfig::default();
		outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
		let mut chan = OutboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&outbound_node_config), channel_value_satoshis, 100_000, 42, &outbound_node_config, 0, 42, None, &logger, None).unwrap();

		let outbound_capped_reserve_perc = if outbound_selected_channel_reserve_perc.lt(&1.0) {
			outbound_selected_channel_reserve_perc
		} else {
			1.0
		};

		let inbound_capped_reserve_perc = if inbound_selected_channel_reserve_perc.lt(&1.0) {
			inbound_selected_channel_reserve_perc
		} else {
			1.0
		};

		let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.funding.get_value_satoshis() as f64 * outbound_capped_reserve_perc) as u64);
		assert_eq!(chan.funding.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);

		let chan_open_channel_msg = chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
		let mut inbound_node_config = UserConfig::default();
		inbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (inbound_selected_channel_reserve_perc * 1_000_000.0) as u32;

		if outbound_selected_channel_reserve_perc + inbound_selected_channel_reserve_perc < 1.0 {
			let chan_inbound_node = InboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, None).unwrap();

			let expected_inbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.funding.get_value_satoshis() as f64 * inbound_capped_reserve_perc) as u64);

			assert_eq!(chan_inbound_node.funding.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
			assert_eq!(chan_inbound_node.funding.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
		} else {
			// Channel Negotiations failed
			let result = InboundV1Channel::<&TestKeysInterface>::new(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, None);
			assert!(result.is_err());
		}
	}

	#[test]
	#[rustfmt::skip]
	fn channel_update() {
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let logger = TestLogger::new();
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let best_block = BlockLocator::from_network(network);
		let chain_hash = ChainHash::using_genesis_block(network);
		let keys_provider = TestKeysInterface::new(&seed, network);

		// Create Node A's channel pointing to Node B's pubkey
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let config = UserConfig::default();
		let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42, None, &logger, None).unwrap();

		// Create Node B's channel by receiving Node A's open_channel message
		// Make sure A's dust limit is as we expect.
		let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
		let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_channel_type_features(&config), &channelmanager::provided_init_features(&config), &open_channel_msg, 7, &config, 0, &&logger, None).unwrap();

		// Node B --> Node A: accept channel, explicitly setting B's dust limit.
		let mut accept_channel_msg = node_b_chan.accept_inbound_channel(&&logger).unwrap();
		accept_channel_msg.common_fields.dust_limit_satoshis = 546;
		node_a_chan.accept_channel(&accept_channel_msg, &config.channel_handshake_limits, &channelmanager::provided_init_features(&config)).unwrap();
		node_a_chan.context.holder_dust_limit_satoshis = 1560;

		// Node A --> Node B: funding created
		let output_script = node_a_chan.funding.get_funding_redeemscript();
		let tx = Transaction { version: Version::ONE, lock_time: LockTime::ZERO, input: Vec::new(), output: vec![TxOut {
			value: Amount::from_sat(10000000), script_pubkey: output_script.clone(),
		}]};
		let funding_outpoint = OutPoint{ txid: tx.compute_txid(), index: 0 };
		let funding_created_msg = node_a_chan.get_funding_created(tx.clone(), funding_outpoint, false, &&logger).map_err(|_| ()).unwrap();
		let (_, funding_signed_msg, _) = node_b_chan.funding_created(&funding_created_msg.unwrap(), best_block, &&keys_provider, &&logger).map_err(|_| ()).unwrap();

		// Node B --> Node A: funding signed
		let res = node_a_chan.funding_signed(&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger);
		let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };

		// Make sure that receiving a channel update will update the Channel as expected.
		let update = ChannelUpdate {
			contents: UnsignedChannelUpdate {
				chain_hash,
				short_channel_id: 0,
				timestamp: 0,
				message_flags: 1, // Only must_be_one
				channel_flags: 0,
				cltv_expiry_delta: 100,
				htlc_minimum_msat: 5,
				htlc_maximum_msat: MAX_VALUE_MSAT,
				fee_base_msat: 110,
				fee_proportional_millionths: 11,
				excess_data: Vec::new(),
			},
			signature: Signature::from(unsafe { FFISignature::new() })
		};
		assert!(node_a_chan.channel_update(&update).unwrap());

		// The counterparty can send an update with a higher minimum HTLC, but that shouldn't
		// change our official htlc_minimum_msat.
		assert_eq!(node_a_chan.context.holder_htlc_minimum_msat, 1);
		match node_a_chan.context.counterparty_forwarding_info() {
			Some(info) => {
				assert_eq!(info.cltv_expiry_delta, 100);
				assert_eq!(info.fee_base_msat, 110);
				assert_eq!(info.fee_proportional_millionths, 11);
			},
			None => panic!("expected counterparty forwarding info to be Some")
		}

		assert!(!node_a_chan.channel_update(&update).unwrap());
	}

	#[test]
	fn blinding_point_skimmed_fee_malformed_ser() {
		// Ensure that channel blinding points, skimmed fees, and malformed HTLCs are (de)serialized
		// properly.
		let logger = TestLogger::new();
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let best_block = BlockLocator::from_network(network);
		let keys_provider = TestKeysInterface::new(&seed, network);

		let node_b_node_id =
			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let config = UserConfig::default();
		let features = channelmanager::provided_init_features(&config);
		let mut outbound_chan = OutboundV1Channel::<&TestKeysInterface>::new(
			&feeest,
			&&keys_provider,
			&&keys_provider,
			node_b_node_id,
			&features,
			10000000,
			100000,
			42,
			&config,
			0,
			42,
			None,
			&logger,
			None,
		)
		.unwrap();
		let open_channel_msg = &outbound_chan
			.get_open_channel(ChainHash::using_genesis_block(network), &&logger)
			.unwrap();
		let mut inbound_chan = InboundV1Channel::<&TestKeysInterface>::new(
			&feeest,
			&&keys_provider,
			&&keys_provider,
			node_b_node_id,
			&channelmanager::provided_channel_type_features(&config),
			&features,
			open_channel_msg,
			7,
			&config,
			0,
			&&logger,
			None,
		)
		.unwrap();
		outbound_chan
			.accept_channel(
				&inbound_chan.get_accept_channel_message(&&logger).unwrap(),
				&config.channel_handshake_limits,
				&features,
			)
			.unwrap();
		let tx = Transaction {
			version: Version::ONE,
			lock_time: LockTime::ZERO,
			input: Vec::new(),
			output: vec![TxOut {
				value: Amount::from_sat(10000000),
				script_pubkey: outbound_chan.funding.get_funding_redeemscript(),
			}],
		};
		let funding_outpoint = OutPoint { txid: tx.compute_txid(), index: 0 };
		let funding_created = outbound_chan
			.get_funding_created(tx.clone(), funding_outpoint, false, &&logger)
			.map_err(|_| ())
			.unwrap()
			.unwrap();
		let mut chan = match inbound_chan.funding_created(
			&funding_created,
			best_block,
			&&keys_provider,
			&&logger,
		) {
			Ok((chan, _, _)) => chan,
			Err((_, e)) => panic!("{}", e),
		};

		let dummy_htlc_source = HTLCSource::OutboundRoute {
			path: Path {
				hops: vec![RouteHop {
					pubkey: test_utils::pubkey(2),
					channel_features: ChannelFeatures::empty(),
					node_features: NodeFeatures::empty(),
					short_channel_id: 0,
					fee_msat: 0,
					cltv_expiry_delta: 0,
					maybe_announced_channel: false,
				}],
				blinded_tail: None,
			},
			session_priv: test_utils::privkey(42),
			first_hop_htlc_msat: 0,
			payment_id: PaymentId([42; 32]),
			bolt12_invoice: None,
		};
		let dummy_outbound_output = OutboundHTLCOutput {
			htlc_id: 0,
			amount_msat: 0,
			payment_hash: PaymentHash([43; 32]),
			cltv_expiry: 0,
			state: OutboundHTLCState::Committed,
			source: dummy_htlc_source.clone(),
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		};
		let mut pending_outbound_htlcs = vec![dummy_outbound_output.clone(); 10];
		for (idx, htlc) in pending_outbound_htlcs.iter_mut().enumerate() {
			if idx % 2 == 0 {
				htlc.blinding_point = Some(test_utils::pubkey(42 + idx as u8));
			}
			if idx % 3 == 0 {
				htlc.skimmed_fee_msat = Some(1);
			}
		}
		chan.context.pending_outbound_htlcs = pending_outbound_htlcs.clone();

		let dummy_holding_cell_add_htlc = HTLCUpdateAwaitingACK::AddHTLC {
			amount_msat: 0,
			cltv_expiry: 0,
			payment_hash: PaymentHash([43; 32]),
			source: dummy_htlc_source.clone(),
			onion_routing_packet: msgs::OnionPacket {
				version: 0,
				public_key: Ok(test_utils::pubkey(1)),
				hop_data: [0; 20 * 65],
				hmac: [0; 32],
			},
			skimmed_fee_msat: None,
			blinding_point: None,
			hold_htlc: None,
			accountable: false,
		};
		let dummy_holding_cell_claim_htlc = |attribution_data| HTLCUpdateAwaitingACK::ClaimHTLC {
			payment_preimage: PaymentPreimage([42; 32]),
			htlc_id: 0,
			attribution_data,
		};
		let dummy_holding_cell_failed_htlc =
			|htlc_id, attribution_data| HTLCUpdateAwaitingACK::FailHTLC {
				htlc_id,
				err_packet: msgs::OnionErrorPacket { data: vec![42], attribution_data },
			};
		let dummy_holding_cell_malformed_htlc =
			|htlc_id| HTLCUpdateAwaitingACK::FailMalformedHTLC {
				htlc_id,
				failure_code: LocalHTLCFailureReason::InvalidOnionBlinding.failure_code(),
				sha256_of_onion: [0; 32],
			};
		let mut holding_cell_htlc_updates = Vec::with_capacity(12);
		for i in 0..16 {
			match i % 7 {
				0 => {
					holding_cell_htlc_updates.push(dummy_holding_cell_add_htlc.clone());
				},
				1 => {
					holding_cell_htlc_updates.push(dummy_holding_cell_claim_htlc(None));
				},
				2 => {
					holding_cell_htlc_updates
						.push(dummy_holding_cell_claim_htlc(Some(AttributionData::new())));
				},
				3 => {
					let mut dummy_add = dummy_holding_cell_add_htlc.clone();
					if let HTLCUpdateAwaitingACK::AddHTLC {
						ref mut blinding_point,
						ref mut skimmed_fee_msat,
						..
					} = &mut dummy_add
					{
						*blinding_point = Some(test_utils::pubkey(42 + i));
						*skimmed_fee_msat = Some(42);
					} else {
						panic!()
					}
					holding_cell_htlc_updates.push(dummy_add);
				},
				4 => {
					holding_cell_htlc_updates.push(dummy_holding_cell_malformed_htlc(i as u64));
				},
				5 => {
					holding_cell_htlc_updates.push(dummy_holding_cell_failed_htlc(i as u64, None));
				},
				_ => {
					holding_cell_htlc_updates.push(dummy_holding_cell_failed_htlc(
						i as u64,
						Some(AttributionData::new()),
					));
				},
			}
		}
		chan.context.holding_cell_htlc_updates = holding_cell_htlc_updates.clone();

		// Encode and decode the channel and ensure that the HTLCs within are the same.
		let encoded_chan = chan.encode();
		let mut s = crate::io::Cursor::new(&encoded_chan);
		let mut reader =
			crate::util::ser::FixedLengthReader::new(&mut s, encoded_chan.len() as u64);
		let features = channelmanager::provided_channel_type_features(&config);
		let decoded_chan =
			FundedChannel::read(&mut reader, (&&keys_provider, &&keys_provider, &features))
				.unwrap();
		assert_eq!(decoded_chan.context.pending_outbound_htlcs, pending_outbound_htlcs);
		assert_eq!(decoded_chan.context.holding_cell_htlc_updates, holding_cell_htlc_updates);
	}

	#[cfg(ldk_test_vectors)]
	macro_rules! test_commitment_common {
			( $chan: expr, $logger: expr, $secp_ctx: expr, $signer: expr, $holder_pubkeys: expr, $per_commitment_point: expr, $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $channel_type_features: expr, {
				$( { $htlc_idx: expr, $counterparty_htlc_sig_hex: expr, $htlc_sig_hex: expr, $htlc_tx_hex: expr, $preimage: expr } ), *
			} ) => { {
				let commitment_data = $chan.context.build_commitment_transaction(&$chan.funding,
					0xffffffffffff - 42, &$per_commitment_point, true, false, &$logger);
				let commitment_tx = commitment_data.tx;
				let trusted_tx = commitment_tx.trust();
				let unsigned_tx = trusted_tx.built_transaction();
				let redeemscript = $chan.funding.get_funding_redeemscript();
				let counterparty_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_sig_hex).unwrap()[..]).unwrap();
				let sighash = unsigned_tx.get_sighash_all(&redeemscript, $chan.funding.get_value_satoshis());
				log_trace!($logger, "unsigned_tx = {}", serialize(&unsigned_tx.transaction).as_hex());
				assert!($secp_ctx.verify_ecdsa(&sighash, &counterparty_signature, $chan.funding.counterparty_funding_pubkey()).is_ok(), "verify counterparty commitment sig");

				let mut per_htlc: Vec<(HTLCOutputInCommitment, Option<Signature>)> = Vec::new();
				per_htlc.clear(); // Don't warn about excess mut for no-HTLC calls
				let mut counterparty_htlc_sigs = Vec::new();
				counterparty_htlc_sigs.clear(); // Don't warn about excess mut for no-HTLC calls
				$({
					let remote_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
					per_htlc.push((commitment_tx.nondust_htlcs()[$htlc_idx].clone(), Some(remote_signature)));
					counterparty_htlc_sigs.push(remote_signature);
				})*
				assert_eq!(commitment_tx.nondust_htlcs().len(), per_htlc.len());

				let holder_commitment_tx = HolderCommitmentTransaction::new(
					commitment_tx.clone(),
					counterparty_signature,
					counterparty_htlc_sigs,
					&$holder_pubkeys.funding_pubkey,
					$chan.funding.counterparty_funding_pubkey()
				);
				let holder_sig = $signer.sign_holder_commitment(&$chan.funding.channel_transaction_parameters, &holder_commitment_tx, &$secp_ctx).unwrap();
				assert_eq!(Signature::from_der(&<Vec<u8>>::from_hex($sig_hex).unwrap()[..]).unwrap(), holder_sig, "holder_sig");

				let funding_redeemscript = $chan.funding.get_funding_redeemscript();
				let tx = holder_commitment_tx.add_holder_sig(&funding_redeemscript, holder_sig);
				assert_eq!(serialize(&tx)[..], <Vec<u8>>::from_hex($tx_hex).unwrap()[..], "tx");

				// ((htlc, counterparty_sig), (index, holder_sig))
				let mut htlc_counterparty_sig_iter = holder_commitment_tx.counterparty_htlc_sigs.iter();

				$({
					let (htlc_sighashtype, num_anchors) = if $channel_type_features.supports_anchor_zero_fee_commitments() {
						(EcdsaSighashType::SinglePlusAnyoneCanPay, 1)
					} else if $channel_type_features.supports_anchors_zero_fee_htlc_tx() {
						(EcdsaSighashType::SinglePlusAnyoneCanPay, 2)
					} else {
						(EcdsaSighashType::All, 0)
					};

					log_trace!($logger, "verifying htlc {}", $htlc_idx);
					let remote_signature = Signature::from_der(&<Vec<u8>>::from_hex($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();

					let ref htlc = commitment_tx.nondust_htlcs()[$htlc_idx];
					let keys = commitment_tx.trust().keys();
					let mut htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, $chan.context.feerate_per_kw,
						$chan.funding.get_counterparty_selected_contest_delay().unwrap(),
						&htlc, $channel_type_features, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
					let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, $channel_type_features, &keys);
					let htlc_sighash = Message::from_digest(sighash::SighashCache::new(&htlc_tx).p2wsh_signature_hash(0, &htlc_redeemscript, htlc.to_bitcoin_amount(), htlc_sighashtype).unwrap().as_raw_hash().to_byte_array());
					assert!($secp_ctx.verify_ecdsa(&htlc_sighash, &remote_signature, &keys.countersignatory_htlc_key.to_public_key()).is_ok(), "verify counterparty htlc sig");

					// Only HTLC success transactions for received htlcs should have a preimage supplied.
					assert_eq!(htlc.offered, $preimage.is_none(), "htlc is offered: {}, with preimage: {:?}", htlc.offered, $preimage);

					let htlc_counterparty_sig = htlc_counterparty_sig_iter.next().unwrap();
					let htlc_holder_sig = $signer.sign_holder_htlc_transaction(&htlc_tx, 0, &HTLCDescriptor {
						channel_derivation_parameters: ChannelDerivationParameters {
							value_satoshis: $chan.funding.get_value_satoshis(),
							keys_id: $chan.context.channel_keys_id,
							transaction_parameters: $chan.funding.channel_transaction_parameters.clone(),
						},
						commitment_txid: trusted_tx.txid(),
						per_commitment_number: trusted_tx.commitment_number(),
						per_commitment_point: trusted_tx.per_commitment_point(),
						feerate_per_kw: trusted_tx.negotiated_feerate_per_kw(),
						htlc: htlc.clone(),
						preimage: $preimage.clone(),
						counterparty_sig: *htlc_counterparty_sig,
					}, &$secp_ctx).unwrap();
					assert_eq!(htlc.transaction_output_index, Some($htlc_idx + num_anchors), "output index");

					let signature = Signature::from_der(&<Vec<u8>>::from_hex($htlc_sig_hex).unwrap()[..]).unwrap();
					assert_eq!(signature, htlc_holder_sig, "htlc sig");
					htlc_tx.input[0].witness = chan_utils::build_htlc_input_witness(
						&htlc_holder_sig, htlc_counterparty_sig, &$preimage, &htlc_redeemscript,
						$channel_type_features,
					);
					log_trace!($logger, "htlc_tx = {}", serialize(&htlc_tx).as_hex());
					assert_eq!(serialize(&htlc_tx)[..], <Vec<u8>>::from_hex($htlc_tx_hex).unwrap()[..], "htlc tx");
				})*
				assert!(htlc_counterparty_sig_iter.next().is_none());
			} }
		}

	#[cfg(ldk_test_vectors)]
	#[test]
	fn outbound_commitment_test() {
		assert!(cfg!(not(feature = "grind_signatures")));

		use crate::ln::chan_utils::{
			ChannelPublicKeys, CounterpartyChannelTransactionParameters,
			HolderCommitmentTransaction,
		};
		use crate::ln::channel::{HTLCOutputInCommitment, PredictedNextFee};
		use crate::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint};
		use crate::sign::{ecdsa::EcdsaChannelSigner, ChannelDerivationParameters, HTLCDescriptor};
		use crate::sync::Arc;
		use crate::types::payment::PaymentPreimage;
		use crate::util::logger::Logger;
		use crate::util::test_utils::{
			preimage_from_hex, pubkey_from_hex, public_from_secret_hex, secret_from_hex,
		};
		use bitcoin::consensus::encode::serialize;
		use bitcoin::hash_types::Txid;
		use bitcoin::hex::DisplayHex;
		use bitcoin::hex::FromHex;
		use bitcoin::secp256k1::Message;
		use bitcoin::sighash;
		use bitcoin::sighash::EcdsaSighashType;
		use core::str::FromStr;

		// Test vectors from BOLT 3 Appendices C and F (anchors):
		let feeest = TestFeeEstimator::new(15000);
		let logger: Arc<dyn Logger> = Arc::new(TestLogger::new());
		let secp_ctx = Secp256k1::new();

		let signer = InMemorySigner::new(
			secret_from_hex("30ff4956bbdd3222d44cc5e8a1261dab1e07957bdac5ae88fe3261ef321f3749"),
			secret_from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
			secret_from_hex("1111111111111111111111111111111111111111111111111111111111111111"),
			secret_from_hex("1111111111111111111111111111111111111111111111111111111111111111"),
			true,
			secret_from_hex("3333333333333333333333333333333333333333333333333333333333333333"),
			secret_from_hex("1111111111111111111111111111111111111111111111111111111111111111"),
			// These aren't set in the test vectors:
			[
				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,
			],
			[0; 32],
			[0; 32],
		);

		let holder_pubkeys = signer.pubkeys(&secp_ctx);
		assert_eq!(
			holder_pubkeys.funding_pubkey,
			pubkey_from_hex("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb")
		);
		let keys_provider = Keys { signer: signer.clone() };

		let counterparty_node_id =
			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let mut config = UserConfig::default();
		config.channel_handshake_config.announce_for_forwarding = false;
		let mut chan = OutboundV1Channel::<&Keys>::new(
			&LowerBoundedFeeEstimator::new(&feeest),
			&&keys_provider,
			&&keys_provider,
			counterparty_node_id,
			&channelmanager::provided_init_features(&config),
			10_000_000,
			0,
			42,
			&config,
			0,
			42,
			None,
			&*logger,
			None,
		)
		.unwrap(); // Nothing uses their network key in this test
		chan.context.holder_dust_limit_satoshis = 546;
		chan.funding.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel

		let funding_txid =
			Txid::from_str("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be")
				.unwrap();
		let funding_info = OutPoint { txid: funding_txid, index: 0 };

		let counterparty_pubkeys = ChannelPublicKeys {
			funding_pubkey: public_from_secret_hex(
				&secp_ctx,
				"1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13",
			),
			revocation_basepoint: RevocationBasepoint::from(pubkey_from_hex(
				"02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27",
			)),
			payment_point: public_from_secret_hex(
				&secp_ctx,
				"4444444444444444444444444444444444444444444444444444444444444444",
			),
			delayed_payment_basepoint: DelayedPaymentBasepoint::from(public_from_secret_hex(
				&secp_ctx,
				"1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13",
			)),
			htlc_basepoint: HtlcBasepoint::from(public_from_secret_hex(
				&secp_ctx,
				"4444444444444444444444444444444444444444444444444444444444444444",
			)),
		};
		chan.funding.channel_transaction_parameters.counterparty_parameters =
			Some(CounterpartyChannelTransactionParameters {
				pubkeys: counterparty_pubkeys.clone(),
				selected_contest_delay: 144,
			});
		chan.funding.channel_transaction_parameters.funding_outpoint = Some(funding_info);

		assert_eq!(
			counterparty_pubkeys.payment_point,
			pubkey_from_hex("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991"),
		);

		assert_eq!(
			counterparty_pubkeys.funding_pubkey,
			pubkey_from_hex("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1")
		);

		assert_eq!(
			counterparty_pubkeys.htlc_basepoint.to_public_key(),
			pubkey_from_hex("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991")
		);

		// We can't just use build_holder_transaction_keys here as the per_commitment_secret is not
		// derived from a commitment_seed, so instead we copy it here and call
		// build_commitment_transaction.
		let per_commitment_secret =
			secret_from_hex("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100");
		let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);

		macro_rules! test_commitment {
			( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
				chan.funding.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::only_static_remote_key();
				chan.funding.next_local_fee = Mutex::new(PredictedNextFee::default());
				chan.funding.next_remote_fee = Mutex::new(PredictedNextFee::default());
				test_commitment_common!(chan, logger, secp_ctx, signer, holder_pubkeys, per_commitment_point, $counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::only_static_remote_key(), $($remain)*);
			};
		}

		macro_rules! test_commitment_with_anchors {
			( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
				chan.funding.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
				chan.funding.next_local_fee = Mutex::new(PredictedNextFee::default());
				chan.funding.next_remote_fee = Mutex::new(PredictedNextFee::default());
				test_commitment_common!(chan, logger, secp_ctx, signer, holder_pubkeys, per_commitment_point, $counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies(), $($remain)*);
			};
		}

		// anchors: simple commitment tx with no HTLCs and single anchor
		test_commitment_with_anchors!("30440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a8658",
						 "3044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778",
						 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// simple commitment tx with no HTLCs
		chan.funding.value_to_self_msat = 7000000000;

		test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
						 "30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
						 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48454a56a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004730440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae05564714201483045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// anchors: simple commitment tx with no HTLCs
		test_commitment_with_anchors!("3045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f3",
						 "30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
						 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		let payment_preimage_0 =
			preimage_from_hex("0000000000000000000000000000000000000000000000000000000000000000");
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 0,
			amount_msat: 1000000,
			cltv_expiry: 500,
			payment_hash: PaymentHash::from(payment_preimage_0),
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		let payment_preimage_1 =
			preimage_from_hex("0101010101010101010101010101010101010101010101010101010101010101");
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 1,
			amount_msat: 2000000,
			cltv_expiry: 501,
			payment_hash: PaymentHash::from(payment_preimage_1),
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		let payment_preimage_2 =
			preimage_from_hex("0202020202020202020202020202020202020202020202020202020202020202");
		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: 2,
			amount_msat: 2000000,
			cltv_expiry: 502,
			payment_hash: PaymentHash::from(payment_preimage_2),
			state: OutboundHTLCState::Committed,
			source: HTLCSource::dummy(),
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		});

		let payment_preimage_3 =
			preimage_from_hex("0303030303030303030303030303030303030303030303030303030303030303");
		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: 3,
			amount_msat: 3000000,
			cltv_expiry: 503,
			payment_hash: PaymentHash::from(payment_preimage_3),
			state: OutboundHTLCState::Committed,
			source: HTLCSource::dummy(),
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		});

		let payment_preimage_4 =
			preimage_from_hex("0404040404040404040404040404040404040404040404040404040404040404");
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 4,
			amount_msat: 4000000,
			cltv_expiry: 504,
			payment_hash: PaymentHash::from(payment_preimage_4),
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		// commitment tx with all five HTLCs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 0;

		test_commitment!("3044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e5",
		                 "304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e0a06a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea01473044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b",
		                  "30440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce",
		                  "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b00000000000000000001e8030000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d9e29616b8f3959f1d3d7f7ce893ffedcdc407717d0de8e37d808c91d3a7c50d022078c3033f6d00095c8720a4bc943c1b45727818c082e4e3ddbc6d3116435b624b014730440220636de5682ef0c5b61f124ec74e8aa2461a69777521d6998295dcea36bc3338110220165285594b23c50b28b82df200234566628a27bcd17f7f14404bd865354eb3ce012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000", Some(payment_preimage_0) },

		                  { 1,
		                  "30440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f896004",
		                  "3045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f",
		                  "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b01000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220649fe8b20e67e46cbb0d09b4acea87dbec001b39b08dee7bdd0b1f03922a8640022037c462dff79df501cecfdb12ea7f4de91f99230bb544726f6e04527b1f89600401483045022100803159dee7935dba4a1d36a61055ce8fd62caa528573cc221ae288515405a252022029c59e7cffce374fe860100a4a63787e105c3cf5156d40b12dd53ff55ac8cf3f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 2,
		                  "30440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d43352",
		                  "3045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa",
		                  "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b02000000000000000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220770fc321e97a19f38985f2e7732dd9fe08d16a2efa4bcbc0429400a447faf49102204d40b417f3113e1b0944ae0986f517564ab4acd3d190503faf97a6e420d4335201483045022100a437cc2ce77400ecde441b3398fea3c3ad8bdad8132be818227fe3c5b8345989022069d45e7fa0ae551ec37240845e2c561ceb2567eacf3076a6a43a502d05865faa012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000", Some(payment_preimage_1) },

		                  { 3,
		                  "304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c1363",
		                  "304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac7487",
		                  "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b03000000000000000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207bcbf4f60a9829b05d2dbab84ed593e0291836be715dc7db6b72a64caf646af802201e489a5a84f7c5cc130398b841d138d031a5137ac8f4c49c770a4959dc3c13630147304402203121d9b9c055f354304b016a36662ee99e1110d9501cb271b087ddb6f382c2c80220549882f3f3b78d9c492de47543cb9a697cecc493174726146536c5954dac748701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 4,
		                  "3044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b87",
		                  "3045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95",
		                  "02000000000101ab84ff284f162cfbfef241f853b47d4368d171f9e2a1445160cd591c4c7d882b04000000000000000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022076dca5cb81ba7e466e349b7128cdba216d4d01659e29b96025b9524aaf0d1899022060de85697b88b21c749702b7d2cfa7dfeaa1f472c8f1d7d9c23f2bf968464b8701483045022100d9080f103cc92bac15ec42464a95f070c7fb6925014e673ee2ea1374d36a7f7502200c65294d22eb20d48564954d5afe04a385551919d8b2ddb4ae2459daaeee1d95012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4)}
		} );

		// commitment tx with seven outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 647;

		test_commitment!("3045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee",
		                 "30450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb7",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8007e80300000000000022002052bfef0479d7b293c27e0f1eb294bea154c63a3294ef092c19af51409bce0e2ad007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484e09c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb701483045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "30450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f",
		                  "30440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b",
		                  "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221008437627f9ad84ac67052e2a414a4367b8556fd1f94d8b02590f89f50525cd33502205b9c21ff6e7fc864f2352746ad8ba59182510819acb644e25b8a12fc37bbf24f014730440220344b0deb055230d01703e6c7acd45853c4af2328b49b5d8af4f88a060733406602202ea64f2a43d5751edfe75503cbc35a62e3141b5ed032fa03360faf4ca66f670b012000000000000000000000000000000000000000000000000000000000000000008a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc688527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f401b175ac686800000000", Some(payment_preimage_0) },

		                  { 1,
		                  "304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c",
		                  "30450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f",
		                  "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe0100000000000000000124060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205a67f92bf6845cf2892b48d874ac1daf88a36495cf8a06f93d83180d930a6f75022031da1621d95c3f335cc06a3056cf960199dae600b7cf89088f65fc53cdbef28c014830450221009e5e3822b0185c6799a95288c597b671d6cc69ab80f43740f00c6c3d0752bdda02206da947a74bd98f3175324dc56fdba86cc783703a120a6f0297537e60632f4c7f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 2,
		                  "30440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c8",
		                  "3045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673",
		                  "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe020000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220437e21766054a3eef7f65690c5bcfa9920babbc5af92b819f772f6ea96df6c7402207173622024bd97328cfb26c6665e25c2f5d67c319443ccdc60c903217005d8c801483045022100fcfc47e36b712624677626cef3dc1d67f6583bd46926a6398fe6b00b0c9a37760220525788257b187fc775c6370d04eadf34d06f3650a63f8df851cee0ecb47a1673012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000", Some(payment_preimage_1) },

		                  { 3,
		                  "304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c64",
		                  "3045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee",
		                  "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe030000000000000000010c0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207436e10737e4df499fc051686d3e11a5bb2310e4d1f1e691d287cef66514791202207cb58e71a6b7a42dd001b7e3ae672ea4f71ea3e1cd412b742e9124abb0739c6401483045022100e78211b8409afb7255ffe37337da87f38646f1faebbdd61bc1920d69e3ead67a02201a626305adfcd16bfb7e9340928d9b6305464eab4aa4c4a3af6646e9b9f69dee01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 4,
		                  "30450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca",
		                  "3044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9",
		                  "020000000001012cfb3e4788c206881d38f2996b6cb2109b5935acb527d14bdaa7b908afa9b2fe04000000000000000001da0d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004830450221009acd6a827a76bfee50806178dfe0495cd4e1d9c58279c194c7b01520fe68cb8d022024d439047c368883e570997a7d40f0b430cb5a742f507965e7d3063ae3feccca01473044022048762cf546bbfe474f1536365ea7c416e3c0389d60558bc9412cb148fb6ab68202207215d7083b75c96ff9d2b08c59c34e287b66820f530b486a9aa4cdd9c347d5b9012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4)}
		} );

		// commitment tx with six outputs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 648;

		test_commitment!("304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e5",
		                 "3045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e9",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4844e9d6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e90147304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e0",
		                  "304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec6",
		                  "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10000000000000000000123060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100a031202f3be94678f0e998622ee95ebb6ada8da1e9a5110228b5e04a747351e4022010ca6a21e18314ed53cfaae3b1f51998552a61a468e596368829a50ce40110e00148304502210097e1873b57267730154595187a34949d3744f52933070c74757005e61ce2112e02204ecfba2aa42d4f14bdf8bad4206bb97217b702e6c433e0e1b0ce6587e6d46ec601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 1,
		                  "304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d384124",
		                  "3044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae",
		                  "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf10100000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202361012a634aee7835c5ecdd6413dcffa8f404b7e77364c792cff984e4ee71e90220715c5e90baa08daa45a7439b1ee4fa4843ed77b19c058240b69406606d38412401473044022019de73b00f1d818fb388e83b2c8c31f6bce35ac624e215bc12f88f9dc33edf48022006ff814bb9f700ee6abc3294e146fac3efd4f13f0005236b41c0a946ee00c9ae012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000", Some(payment_preimage_1) },

		                  { 2,
		                  "304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc625532989",
		                  "3045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e2260796",
		                  "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf1020000000000000000010b0a0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207e8e82cd71ed4febeb593732c260456836e97d81896153ecd2b3cf320ca6861702202dd4a30f68f98ced7cc56a36369ac1fdd978248c5ff4ed204fc00cc62553298901483045022100bd0be6100c4fd8f102ec220e1b053e4c4e2ecca25615490150007b40d314dc3902201a1e0ea266965b43164d9e6576f58fa6726d42883dd1c3996d2925c2e226079601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 3,
		                  "3044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be",
		                  "3045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6",
		                  "020000000001010f44041fdfba175987cf4e6135ba2a154e3b7fb96483dc0ed5efc0678e5b6bf103000000000000000001d90d0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022024cd52e4198c8ae0e414a86d86b5a65ea7450f2eb4e783096736d93395eca5ce022078f0094745b45be4d4b2b04dd5978c9e66ba49109e5704403e84aaf5f387d6be01483045022100bbfb9d0a946d420807c86e985d636cceb16e71c3694ed186316251a00cbd807202207773223f9a337e145f64673825be9b30d07ef1542c82188b264bedcf7cda78c6012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// anchors: commitment tx with six outputs untrimmed (minimum dust limit)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 645;
		chan.context.holder_dust_limit_satoshis = 1001;

		test_commitment_with_anchors!("3044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc312",
		                 "3045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d0051",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80084a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d0070000000000002200203e68115ae0b15b8de75b6c6bc9af5ac9f01391544e0870dae443a1e8fe7837ead007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5eb80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994abc996a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d57697c707b6f6d053febf24b98e8989f186eea42e37e9e91663ec2c70bb8f70022079b0715a472118f262f43016a674f59c015d9cafccec885968e76d9d9c5d005101473044022025d97466c8049e955a5afce28e322f4b34d2561118e52332fb400f9b908cc0a402205dc6fba3a0d67ee142c428c535580cd1f2ff42e2f89b47e0c8a01847caffc31201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc282",
		                  "3045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef09",
		                  "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320002000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e04d160a326432659fe9fb127304c1d348dfeaba840081bdc57d8efd902a48d8022008a824e7cf5492b97e4d9e03c06a09f822775a44f6b5b2533a2088904abfc28283483045022100b7c49846466b13b190ff739bbe3005c105482fc55539e55b1c561f76b6982b6c02200e5c35808619cf543c8405cff9fedd25f333a4a2f6f6d5e8af8150090c40ef0901008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6851b27568f6010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e",
		                  "3045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac",
		                  "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320003000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100fbdc3c367ce3bf30796025cc590ee1f2ce0e72ae1ac19f5986d6d0a4fc76211f02207e45ae9267e8e820d188569604f71d1abd11bd385d58853dd7dc034cdb3e9a6e83483045022100d29330f24db213b262068706099b39c15fa7e070c3fcdf8836c09723fc4d365602203ce57d01e9f28601e461a0b5c4a50119b270bde8b70148d133a6849c70b115ac012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000", Some(payment_preimage_1) },

		                  { 2,
		                  "3044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c1",
		                  "304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e",
		                  "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320004000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022066c5ef625cee3ddd2bc7b6bfb354b5834cf1cc6d52dd972fb41b7b225437ae4a022066cb85647df65c6b87a54e416dcdcca778a776c36a9643d2b5dc793c9b29f4c18347304402202d4ce515cd9000ec37575972d70b8d24f73909fb7012e8ebd8c2066ef6fe187902202830b53e64ea565fecd0f398100691da6bb2a5cf9bb0d1926f1d71d05828a11e01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000", None::<PaymentPreimage> },

		                  { 3,
		                  "3044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc615",
		                  "3045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226",
		                  "02000000000101104f394af4c4fad78337f95e3e9f802f4c0d86ab231853af09b285348561320005000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022022c7e11595c53ee89a57ca76baf0aed730da035952d6ab3fe6459f5eff3b337a022075e10cc5f5fd724a35ce4087a5d03cd616698626c69814032132b50bb97dc61583483045022100b20cd63e0587d1711beaebda4730775c4ac8b8b2ec78fe18a0c44c3f168c25230220079abb7fc4924e2fca5950842e5b9e416735585026914570078c4ef62f286226012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with six outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 2069;
		chan.context.holder_dust_limit_satoshis = 546;

		test_commitment!("304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc",
		                 "3045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e33",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8006d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2db80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48477956a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e330148304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f699",
		                  "3045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d",
		                  "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0000000000000000000175020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f33513ee38abf1c582876f921f8fddc06acff48e04515532a32d3938de938ffd02203aa308a2c1863b7d6fdf53159a1465bf2e115c13152546cc5d74483ceaa7f69901483045022100a637902a5d4c9ba9e7c472a225337d5aac9e2e3f6744f76e237132e7619ba0400220035c60d784a031c0d9f6df66b7eab8726a5c25397399ee4aa960842059eb3f9d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df",
		                  "3045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61",
		                  "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d0100000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ce07682cf4b90093c22dc2d9ab2a77ad6803526b655ef857221cc96af5c9e0bf02200f501cee22e7a268af40b555d15a8237c9f36ad67ef1841daf9f6a0267b1e6df01483045022100e57e46234f8782d3ff7aa593b4f7446fb5316c842e693dc63ee324fd49f6a1c302204a2f7b44c48bd26e1554422afae13153eb94b29d3687b733d18930615fb2db61012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000", Some(payment_preimage_1) },

		                  { 2,
		                  "3045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e0",
		                  "3044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c18",
		                  "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d020000000000000000015d060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e3e35492e55f82ec0bc2f317ffd7a486d1f7024330fe9743c3559fc39f32ef0c02203d1d4db651fc388a91d5ad8ecdd8e83673063bc8eefe27cfd8c189090e3a23e001473044022068613fb1b98eb3aec7f44c5b115b12343c2f066c4277c82b5f873dfe68f37f50022028109b4650f3f528ca4bfe9a467aff2e3e43893b61b5159157119d5d95cf1c1801008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 3,
		                  "304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df",
		                  "3045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33",
		                  "02000000000101adbe717a63fb658add30ada1e6e12ed257637581898abe475c11d7bbcd65bd4d03000000000000000001f2090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402207475aeb0212ef9bf5130b60937817ad88c9a87976988ef1f323f026148cc4a850220739fea17ad3257dcad72e509c73eebe86bee30b178467b9fdab213d631b109df01483045022100d315522e09e7d53d2a659a79cb67fef56d6c4bddf3f46df6772d0d20a7beb7c8022070bcc17e288607b6a72be0bd83368bb6d53488db266c1cdb4d72214e4f02ac33012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with five outputs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 2070;

		test_commitment!("304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c",
		                 "3044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c1",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484da966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c10147304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b",
		                  "30440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e5",
		                  "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff0000000000000000000174020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402205f6b6d12d8d2529fb24f4445630566cf4abbd0f9330ab6c2bdb94222d6a2a0c502202f556258ae6f05b193749e4c541dfcc13b525a5422f6291f073f15617ba8579b014730440220150b11069454da70caf2492ded9e0065c9a57f25ac2a4c52657b1d15b6c6ed85022068a38833b603c8892717206383611bad210f1cbb4b1f87ea29c6c65b9e1cb3e501008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546",
		                  "30450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c6",
		                  "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff010000000000000000015c060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f960dfb1c9aee7ce1437efa65b523e399383e8149790e05d8fed27ff6e42fe0002202fe8613e062ffe0b0c518cc4101fba1c6de70f64a5bcc7ae663f2efae43b8546014830450221009a6ed18e6873bc3644332a6ee21c152a5b102821865350df7a8c74451a51f9f2022050d801fb4895d7d7fbf452824c0168347f5c0cbe821cf6a97a63af5b8b2563c601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 2,
		                  "3045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504",
		                  "30440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502",
		                  "02000000000101403ad7602b43293497a3a2235a12ecefda4f3a1f1d06e49b1786d945685de1ff02000000000000000001f1090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100ae5fc7717ae684bc1fcf9020854e5dbe9842c9e7472879ac06ff95ac2bb10e4e022057728ada4c00083a3e65493fb5d50a232165948a1a0f530ef63185c2c8c56504014730440220408ad3009827a8fccf774cb285587686bfb2ed041f89a89453c311ce9c8ee0f902203c7392d9f8306d3a46522a66bd2723a7eb2628cb2d9b34d4c104f1766bf37502012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with five outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 2194;

		test_commitment!("304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb3",
		                 "3044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d398",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020403d394747cae42e98ff01734ad5c08f82ba123d3d9a620abda88989651e2ab5b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e48440966a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d3980147304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de8450",
		                  "304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e0154301",
		                  "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100939726680351a7856c1bc386d4a1f422c7d29bd7b56afc139570f508474e6c40022023175a799ccf44c017fbaadb924c40b2a12115a5b7d0dfd3228df803a2de84500148304502210099c98c2edeeee6ec0fb5f3bea8b79bb016a2717afa9b5072370f34382de281d302206f5e2980a995e045cf90a547f0752a7ee99d48547bc135258fe7bc07e015430101008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a914b43e1b38138a41b37f7cd9a1d274bc63e3a9b5d188ac6868f6010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a0",
		                  "3045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b77",
		                  "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd010000000000000000010a060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022021bb883bf324553d085ba2e821cad80c28ef8b303dbead8f98e548783c02d1600220638f9ef2a9bba25869afc923f4b5dc38be3bb459f9efa5d869392d5f7779a4a001483045022100fd85bd7697b89c08ec12acc8ba89b23090637d83abd26ca37e01ae93e67c367302202b551fe69386116c47f984aab9c8dfd25d864dcde5d3389cfbef2447a85c4b7701008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 2,
		                  "3045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b",
		                  "30450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3",
		                  "02000000000101153cd825fdb3aa624bfe513e8031d5d08c5e582fb3d1d1fe8faf27d3eed410cd020000000000000000019a090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c9e6f0454aa598b905a35e641a70cc9f67b5f38cc4b00843a041238c4a9f1c4a0220260a2822a62da97e44583e837245995ca2e36781769c52f19e498efbdcca262b014830450221008a9f2ea24cd455c2b64c1472a5fa83865b0a5f49a62b661801e884cf2849af8302204d44180e50bf6adfcf1c1e581d75af91aba4e28681ce4a5ee5f3cbf65eca10f3012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with four outputs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 2195;

		test_commitment!("304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce403",
		                 "3044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d1767",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484b8976a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d17670147304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce40301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e",
		                  "3045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d76",
		                  "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900000000000000000000109060000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100e57b845066a06ee7c2cbfc29eabffe52daa9bf6f6de760066d04df9f9b250e0002202ffb197f0e6e0a77a75a9aff27014bd3de83b7f748d7efef986abe655e1dd50e01483045022100ecc8c6529d0b2316d046f0f0757c1e1c25a636db168ec4f3aa1b9278df685dc0022067ae6b65e936f1337091f7b18a15935b608c5f2cdddb2f892ed0babfdd376d7601008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage>},

		                  { 1,
		                  "3045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a",
		                  "3044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82",
		                  "020000000001018130a10f09b13677ba2885a8bca32860f3a952e5912b829a473639b5a2c07b900100000000000000000199090000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100d193b7ecccad8057571620a0b1ffa6c48e9483311723b59cf536043b20bc51550220546d4bd37b3b101ecda14f6c907af46ec391abce1cd9c7ce22b1a62b534f2f2a01473044022014d66f11f9cacf923807eba49542076c5fe5cccf252fb08fe98c78ef3ca6ab5402201b290dbe043cc512d9d78de074a5a129b8759bc6a6c546b190d120b690bd6e82012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// anchors: commitment tx with four outputs untrimmed (minimum dust limit)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 2185;
		chan.context.holder_dust_limit_satoshis = 2001;
		let cached_channel_type = chan.funding.get_channel_type().clone();
		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();

		test_commitment_with_anchors!("3044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c0",
		                 "3045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd5",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80064a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994b80b000000000000220020f96d0334feb64a4f40eb272031d07afcb038db56aa57446d60308c9f8ccadef9a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ac5916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd501473044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb",
		                  "30440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f",
		                  "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc02000000000100000001b80b0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206870514a72ad6e723ff7f1e0370d7a33c1cd2a0b9272674143ebaf6a1d02dee102205bd953c34faf5e7322e9a1c0103581cb090280fda4f1039ee8552668afa90ebb834730440220669de9ca7910eff65a7773ebd14a9fc371fe88cde5b8e2a81609d85c87ac939b02201ac29472fa4067322e92d75b624942d60be5050139b20bb363db75be79eb946f01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6851b27568f7010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd7271",
		                  "3045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688",
		                  "02000000000101ac13a7715f80b8e52dda43c6929cade5521bdced3a405da02b443f1ffb1e33cc03000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100949e8dd938da56445b1cdfdebe1b7efea086edd05d89910d205a1e2e033ce47102202cbd68b5262ab144d9ec12653f87dfb0bb6bd05d1f58ae1e523f028eaefd727183483045022100e3104ed8b239f8019e5f0a1a73d7782a94a8c36e7984f476c3a0b3cb0e62e27902207e3d52884600985f8a2098e53a5c30dd6a5e857733acfaa07ab2162421ed2688012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with four outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 3702;
		chan.context.holder_dust_limit_satoshis = 546;
		chan.funding.channel_transaction_parameters.channel_type_features =
			cached_channel_type.clone();

		test_commitment!("304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee40169",
		                 "3045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf75",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8004b80b000000000000220020c20b5d1f8584fd90443e7b7b720136174fa4b9333c261d04dbbd012635c0f419a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4846f916a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf750148304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee4016901475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb89",
		                  "304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f",
		                  "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402206fa54c11f98c3bae1e93df43fc7affeb05b476bf8060c03e29c377c69bc08e8b0220672701cce50d5c379ff45a5d2cfe48ac44973adb066ac32608e21221d869bb890147304402206e36c683ebf2cb16bcef3d5439cf8b53cd97280a365ed8acd7abb85a8ba5f21c02206e8621edfc2a5766cbc96eb67fd501127ff163eb6b85518a39f7d4974aef126f01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9148a486ff2e31d6158bf39e2608864d63fefd09d5b88ac6868f7010000", None::<PaymentPreimage> },

		                  { 1,
		                  "3044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb5817",
		                  "304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc",
		                  "020000000001018db483bff65c70ee71d8282aeec5a880e2e2b39e45772bda5460403095c62e3f0100000000000000000176050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022057649739b0eb74d541ead0dfdb3d4b2c15aa192720031044c3434c67812e5ca902201e5ede42d960ae551707f4a6b34b09393cf4dee2418507daa022e3550dbb58170147304402207faad26678c8850e01b4a0696d60841f7305e1832b786110ee9075cb92ed14a30220516ef8ee5dfa80824ea28cbcec0dd95f8b847146257c16960db98507db15ffdc012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with three outputs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 3703;

		test_commitment!("3045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e",
		                 "304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e1",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484eb936a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e101483045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a",
		                  "3045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05",
		                  "0200000000010120060e4a29579d429f0f27c17ee5f1ee282f20d706d6f90b63d35946d8f3029a0000000000000000000175050000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100c34c61735f93f2e324cc873c3b248111ccf8f6db15d5969583757010d4ad2b4602207867bb919b2ddd6387873e425345c9b7fd18d1d66aba41f3607bc2896ef3c30a01483045022100988c143e2110067117d2321bdd4bd16ca1734c98b29290d129384af0962b634e02206c1b02478878c5f547018b833986578f90c3e9be669fe5788ad0072a55acbb05012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// anchors: commitment tx with three outputs untrimmed (minimum dust limit)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 3687;
		chan.context.holder_dust_limit_satoshis = 3001;
		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();

		test_commitment_with_anchors!("3045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c228377",
		                 "3045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80054a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994a00f000000000000220020ce6e751274836ff59622a0d1e07f8831d80bd6730bd48581398bfadd2bb8da9ac0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aa28b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d01483045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c22837701475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c",
		                  "3045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de",
		                  "02000000000101542562b326c08e3a076d9cfca2be175041366591da334d8d513ff1686fd95a6002000000000100000001a00f0000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500473044022017b558a3cf5f0cb94269e2e927b29ed22bd2416abb8a7ce6de4d1256f359b93602202e9ca2b1a23ea3e69f433c704e327739e219804b8c188b1d52f74fd5a9de954c83483045022100af7a8b7c7ff2080c68995254cb66d64d9954edcc5baac3bb4f27ed2d29aaa6120220421c27da7a60574a9263f271e0f3bd34594ec6011095190022b3b54596ea03de012004040404040404040404040404040404040404040404040404040404040404048d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac6851b2756800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with three outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 4914;
		chan.context.holder_dust_limit_satoshis = 546;
		chan.funding.channel_transaction_parameters.channel_type_features =
			cached_channel_type.clone();

		test_commitment!("3045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c95244",
		                 "3045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c19",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8003a00f0000000000002200208c48d15160397c9731df9bc3b236656efb6665fbfe92b4a6878e88a499f741c4c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484ae8f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c1901483045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c9524401475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374",
		                  "30440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10",
		                  "02000000000101a9172908eace869cc35128c31fc2ab502f72e4dff31aab23e0244c4b04b11ab00000000000000000000122020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100f43591c156038ba217756006bb3c55f7d113a325cdd7d9303c82115372858d68022016355b5aadf222bc8d12e426c75f4a03423917b2443a103eb2a498a3a2234374014730440220585dee80fafa264beac535c3c0bb5838ac348b156fdc982f86adc08dfc9bfd250220130abb82f9f295cc9ef423dcfef772fde2acd85d9df48cc538981d26a10a9c10012004040404040404040404040404040404040404040404040404040404040404048a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a91418bc1a114ccf9c052d3d23e28d3b0a9d1227434288527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f801b175ac686800000000", Some(payment_preimage_4) }
		} );

		// commitment tx with two outputs untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 4915;
		chan.context.holder_dust_limit_satoshis = 546;

		test_commitment!("304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a720",
		                 "30450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf5",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8002c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484fa926a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008a953551f4d67cb4df3037207fc082ddaf6be84d417b0bd14c80aab66f1b01a402207508796dc75034b2dee876fe01dc05a08b019f3e5d689ac8842ade2f1befccf50147304402203a286936e74870ca1459c700c71202af0381910a6bfab687ef494ef1bc3e02c902202506c362d0e3bee15e802aa729bf378e051644648253513f1c085b264cc2a72001475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// anchors: commitment tx with two outputs untrimmed (minimum dust limit)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 4894;
		chan.context.holder_dust_limit_satoshis = 4001;
		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();

		test_commitment_with_anchors!("3045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b95",
		                 "30450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ad0886a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd01483045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b9501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// commitment tx with two outputs untrimmed (maximum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 9651180;
		chan.context.holder_dust_limit_satoshis = 546;
		chan.funding.channel_transaction_parameters.channel_type_features =
			cached_channel_type.clone();

		test_commitment!("304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd3",
		                 "3045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b800222020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80ec0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4840400483045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de0147304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// commitment tx with one output untrimmed (minimum feerate)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 9651181;

		test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
		                 "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// anchors: commitment tx with one output untrimmed (minimum dust limit)
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 6216010;
		chan.context.holder_dust_limit_satoshis = 4001;
		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();

		test_commitment_with_anchors!("30450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf",
		                 "30450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a04004830450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1014830450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// commitment tx with fee greater than funder amount
		chan.funding.value_to_self_msat = 6993000000; // 7000000000 - 7000000
		chan.context.feerate_per_kw = 9651936;
		chan.context.holder_dust_limit_satoshis = 546;
		chan.funding.channel_transaction_parameters.channel_type_features = cached_channel_type;

		test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
		                 "304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});

		// commitment tx with 3 htlc outputs, 2 offered having the same amount and preimage
		chan.funding.value_to_self_msat = 7_000_000_000 - 2_000_000;
		chan.context.feerate_per_kw = 253;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 1,
			amount_msat: 2000000,
			cltv_expiry: 501,
			payment_hash: PaymentHash::from(payment_preimage_1),
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		chan.context.pending_outbound_htlcs.clear();
		let payment_preimage_5 =
			preimage_from_hex("0505050505050505050505050505050505050505050505050505050505050505");
		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: 6,
			amount_msat: 5000001,
			cltv_expiry: 506,
			payment_hash: PaymentHash::from(payment_preimage_5),
			state: OutboundHTLCState::Committed,
			source: HTLCSource::dummy(),
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		});

		chan.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
			htlc_id: 5,
			amount_msat: 5000000,
			cltv_expiry: 505,
			payment_hash: PaymentHash::from(payment_preimage_5),
			state: OutboundHTLCState::Committed,
			source: HTLCSource::dummy(),
			skimmed_fee_msat: None,
			blinding_point: None,
			send_timestamp: None,
			hold_htlc: None,
			accountable: false,
		});

		test_commitment!("304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c8",
		                 "304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8005d007000000000000220020748eba944fedc8827f6b06bc44678f93c0f9e6078b35c6331ed31e75f8ce0c2d8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121b8813000000000000220020305c12e1a0bc21e283c131cea1c66d68857d28b7b2fce0a6fbc40c164852121bc0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484a69f6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e040047304402200d10bf5bc5397fc59d7188ae438d80c77575595a2d488e41bd6363a810cc8d72022012b57e714fbbfdf7a28c47d5b370cb8ac37c8545f596216e5b21e9b236ef457c0147304402207d0870964530f97b62497b11153c551dca0a1e226815ef0a336651158da0f82402200f5378beee0e77759147b8a0a284decd11bfd2bc55c8fafa41c134fe996d43c801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "3045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce5",
		                  "3044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b",
		                  "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec000000000000000000011f070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b470fe12e5b7fea9eccb8cbff1972cea4f96758041898982a02bcc7f9d56d50b0220338a75b2afaab4ec00cdd2d9273c68c7581ff5a28bcbb40c4d138b81f1d45ce501473044022017b90c65207522a907fb6a137f9dd528b3389465a8ae72308d9e1d564f512cf402204fc917b4f0e88604a3e994f85bfae7c7c1f9d9e9f78e8cd112e0889720d9405b012001010101010101010101010101010101010101010101010101010101010101018a76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac686800000000", Some(payment_preimage_1) },
		                  { 1,
		                  "3045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a",
		                  "3045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d",
		                  "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec01000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100b575379f6d8743cb0087648f81cfd82d17a97fbf8f67e058c65ce8b9d25df9500220554a210d65b02d9f36c6adf0f639430ca8293196ba5089bf67cc3a9813b7b00a01483045022100ee2e16b90930a479b13f8823a7f14b600198c838161160b9436ed086d3fc57e002202a66fa2324f342a17129949c640bfe934cbc73a869ba7c06aa25c5a3d0bfb53d01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868f9010000", None::<PaymentPreimage> },
		                  { 2,
		                  "30440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc",
		                  "304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb",
		                  "020000000001014bdccf28653066a2c554cafeffdfe1e678e64a69b056684deb0c4fba909423ec02000000000000000001e1120000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220471c9f3ad92e49b13b7b8059f43ecf8f7887b0dccbb9fdb54bfe23d62a8ae332022024bd22fae0740e86a44228c35330da9526fd7306dffb2b9dc362d5e78abef7cc0147304402207157f452f2506d73c315192311893800cfb3cc235cc1185b1cfcc136b55230db022014be242dbc6c5da141fec4034e7f387f74d6ff1899453d72ba957467540e1ecb01008576a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6868fa010000", None::<PaymentPreimage> }
		} );

		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_htlc_fee_and_dependencies();
		test_commitment_with_anchors!("3044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c725",
		                 "3045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b76",
		                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80074a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994d007000000000000220020fe0598d74fee2205cc3672e6e6647706b4f3099713b4661b62482c3addd04a5e881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7881300000000000022002018e40f9072c44350f134bdc887bab4d9bdfc8aa468a25616c80e21757ba5dac7c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994aad9c6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400483045022100b4014970d9d7962853f3f85196144671d7d5d87426250f0a5fdaf9a55292e92502205360910c9abb397467e19dbd63d081deb4a3240903114c98cec0a23591b79b7601473044022027b38dfb654c34032ffb70bb43022981652fce923cbbe3cbe7394e2ade8b34230220584195b78da6e25c2e8da6b4308d9db25b65b64975db9266163ef592abb7c72501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {

		                  { 0,
		                  "30440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c2",
		                  "304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424",
		                  "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c402000000000100000001d0070000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e05004730440220078fe5343dab88c348a3a8a9c1a9293259dbf35507ae971702cc39dd623ea9af022011ed0c0f35243cd0bb4d9ca3c772379b2b5f4af93140e9fdc5600dfec1cdb0c28347304402205df665e2908c7690d2d33eb70e6e119958c28febe141a94ed0dd9a55ce7c8cfc0220364d02663a5d019af35c5cd5fda9465d985d85bbd12db207738d61163449a424012001010101010101010101010101010101010101010101010101010101010101018d76a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c8201208763a9144b6b2e5444c2639cc0fb7bcea5afba3f3cdce23988527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae677502f501b175ac6851b2756800000000", Some(payment_preimage_1) },
		                  { 1,
		                  "304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c",
		                  "304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b",
		                  "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40300000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e050047304402202df6bf0f98a42cfd0172a16bded7d1b16c14f5f42ba23f5c54648c14b647531302200fe1508626817f23925bb56951d5e4b2654c751743ab6db48a6cce7dda17c01c8347304402203f99ec05cdd89558a23683b471c1dcce8f6a92295f1fff3b0b5d21be4d4f97ea022019d29070690fc2c126fe27cc4ab2f503f289d362721b2efa7418e7fddb939a5b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568f9010000", None::<PaymentPreimage> },
		                  { 2,
		                  "3045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a1",
		                  "3045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b",
		                  "020000000001013d060d0305c9616eaabc21d41fae85bcb5477b5d7f1c92aa429cf15339bbe1c40400000000010000000188130000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0500483045022100bd206b420c495f3aa714d3ea4766cbe95441deacb5d2f737f1913349aee7c2ae02200249d2c950dd3b15326bf378ae5d2b871d33d6737f5d70735f3de8383140f2a183483045022100f2cd35e385b9b7e15b92a5d78d120b6b2c5af4e974bc01e884c5facb3bb5966c0220706e0506477ce809a40022d6de8e041e9ef13136c45abee9c36f58a01fdb188b01008876a91414011f7254d96b819c76986c277d115efce6f7b58763ac67210394854aa6eab5b2a8122cc726e9dded053a2184d88256816826d6231c068d4a5b7c820120876475527c21030d417a46946384f88d5f3337267c5e579765875dc4daca813e21734b140639e752ae67a9142002cc93ebefbb1b73f0af055dcc27a0b504ad7688ac6851b27568fa010000", None::<PaymentPreimage> }
		} );
	}

	// Test vectors from bolt03/zero_fee_commitments.json
	#[cfg(ldk_test_vectors)]
	#[test]
	fn zero_fee_commitment_test_vectors() {
		use crate::chain::transaction::OutPoint;
		use crate::ln::chan_utils::{
			CounterpartyChannelTransactionParameters, HolderCommitmentTransaction,
		};
		use crate::ln::channel::HTLCOutputInCommitment;
		use crate::sign::{ecdsa::EcdsaChannelSigner, ChannelDerivationParameters, HTLCDescriptor};
		use crate::sync::Arc;
		use crate::types::features::ChannelTypeFeatures;
		use crate::types::payment::PaymentPreimage;
		use crate::util::config::UserConfig;
		use crate::util::logger::Logger;
		use crate::util::test_utils::{
			payment_hash_from_hex, preimage_from_hex, pubkey_from_hex, secret_from_hex,
		};
		use bitcoin::consensus::encode::serialize;
		use bitcoin::hash_types::Txid;
		use bitcoin::hex::{DisplayHex, FromHex};
		use bitcoin::secp256k1::{Message, Secp256k1};
		use bitcoin::sighash;
		use bitcoin::sighash::EcdsaSighashType;
		use core::str::FromStr;

		let feeest = TestFeeEstimator::new(250); // Fee doesn't matter
		let logger: Arc<dyn Logger> = Arc::new(TestLogger::new());
		let secp_ctx = Secp256k1::new();

		let alice_funding_privkey =
			secret_from_hex("8f567cb6382507019349a47623902aa65d7a142ac85462eeb63dc11799ac2bb9");
		let alice_payment_basepoint_secret =
			secret_from_hex("94f29d20a225ea2f7093331ba0f0f28a9382d8ed08e1fd121329925cd0c01b6d");
		let alice_delayed_payment_basepoint_secret =
			secret_from_hex("e9d4e1935bf16e948d76ad007baf0646df023af38f41bcf2c8799336949d291e");
		let alice_htlc_basepoint_secret =
			secret_from_hex("f699038ef4f95b6b16b22a5c04fcb3c508d68d02cd2f86cf197e0fac451681b0");
		// Not set in test vectors, not required because we're signing Alice's commitment.
		let alice_revocation_base_secret =
			secret_from_hex("1111111111111111111111111111111111111111111111111111111111111111");

		let alice_signer = InMemorySigner::new(
			alice_funding_privkey,
			alice_revocation_base_secret,
			alice_payment_basepoint_secret,
			alice_payment_basepoint_secret,
			true,
			alice_delayed_payment_basepoint_secret,
			alice_htlc_basepoint_secret,
			// Not provided in test vectors.
			[0xff; 32],
			[0; 32],
			[0; 32],
		);
		let alice_keys_provider = Keys { signer: alice_signer.clone() };
		let alice_pubkeys = alice_signer.pubkeys(&secp_ctx);

		let bob_funding_privkey =
			secret_from_hex("4d22d96f0c0ccecffee4554d20ed43e51235917508ee292d281235bb7ebe0e3e");
		let bob_payment_basepoint_secret =
			secret_from_hex("580bff39085f3a6ae8b1f32905e67366c522ea8f2418391145b2e98f1a7cb3f2");
		let bob_htlc_basepoint_secret =
			secret_from_hex("32df9c4dd46ab6210e74e81e15282106f8db883f45674eabb3324166c6513062");
		let bob_revocation_base_secret =
			secret_from_hex("2222222222222222222222222222222222222222222222222222222222222222");
		let bob_delayed_payment_basepoint_secret =
			secret_from_hex("2222222222222222222222222222222222222222222222222222222222222222");

		let bob_signer = InMemorySigner::new(
			bob_funding_privkey,
			bob_revocation_base_secret,
			bob_payment_basepoint_secret,
			bob_payment_basepoint_secret,
			true,
			bob_delayed_payment_basepoint_secret,
			bob_htlc_basepoint_secret,
			// Not provided in test vectors.
			[0xff; 32],
			[0; 32],
			[0; 32],
		);

		// Test vectors only provide revocation_basepoint for bob, override it here.
		let mut bob_pubkeys = bob_signer.pubkeys(&secp_ctx);
		bob_pubkeys.revocation_basepoint = RevocationBasepoint(pubkey_from_hex(
			"026788d019ed90149cbc9aa5ff26dd7f1a6d3cd1bee8bf36cf7d8310fbd3606b14",
		));

		// Node id for alice and bob doesn't matter to our test vectors.
		let bob_node_id = crate::util::test_utils::pubkey(2);
		let mut config = UserConfig::default();
		config.channel_handshake_config.negotiate_anchor_zero_fee_commitments = true;

		let mut chan = OutboundV1Channel::<&Keys>::new(
			&LowerBoundedFeeEstimator::new(&feeest),
			&&alice_keys_provider,
			&&alice_keys_provider,
			bob_node_id,
			&crate::ln::channelmanager::provided_init_features(&config),
			10_000_000,
			0,
			0,
			&config,
			0,
			0,
			None,
			&*logger,
			None,
		)
		.unwrap();

		chan.funding.counterparty_selected_channel_reserve_satoshis = Some(0);
		chan.funding.holder_selected_channel_reserve_satoshis = 0;

		let funding_txid_str = "4b70a2ee47b3005a6316ff87055e94c6b3d433d0fd3b384c9ecf7813843c1eae";
		let funding_info = OutPoint { txid: Txid::from_str(funding_txid_str).unwrap(), index: 1 };

		// Must override alice's keys because we use a fixed revocation_basepoint.
		chan.funding.channel_transaction_parameters.holder_pubkeys = alice_pubkeys.clone();
		chan.funding.channel_transaction_parameters.counterparty_parameters =
			Some(CounterpartyChannelTransactionParameters {
				pubkeys: bob_pubkeys.clone(),
				selected_contest_delay: 720,
			});
		chan.funding.channel_transaction_parameters.funding_outpoint = Some(funding_info);
		chan.funding.channel_transaction_parameters.channel_type_features =
			ChannelTypeFeatures::anchors_zero_fee_commitments();

		let per_commitment_point =
			pubkey_from_hex("0275d12130c276b4274358a328901f8fc47e6c72629102e4b46c9f27dd2c1dda98");

		macro_rules! test_commitment_with_zero_fee {
			( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
				chan.funding.channel_transaction_parameters.channel_type_features = ChannelTypeFeatures::anchors_zero_fee_commitments();
				test_commitment_common!(chan, logger, secp_ctx, alice_signer, alice_pubkeys, per_commitment_point,
				$counterparty_sig_hex, $sig_hex, $tx_hex, &ChannelTypeFeatures::anchors_zero_fee_commitments(), $($remain)*);
			};
		}

		// Commitment transaction without HTLCs, both outputs untrimmed
		chan.funding.value_to_self_msat = 8000000000;
		test_commitment_with_zero_fee!(
			"3045022100a05afcdfaf045a0a7b6adb194dcda430bb8e47db8c6d1536b2a94bd98fed77ed02206d580dcd5cba42aebed39515fbd00fdd90480825ae23cce87eef1f1711e2125e",
			"304502210094afa18972599f7a78b06467bd11d742875baf74aa9e516a775720564671fd8e02206b9ed5f48fb92a1c19543d67f29ee3bd43afee1ec1af6f7f9b4e3371beb82162",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800300000000000000000451024e7380841e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152ea00127a0000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0400483045022100a05afcdfaf045a0a7b6adb194dcda430bb8e47db8c6d1536b2a94bd98fed77ed02206d580dcd5cba42aebed39515fbd00fdd90480825ae23cce87eef1f1711e2125e0148304502210094afa18972599f7a78b06467bd11d742875baf74aa9e516a775720564671fd8e02206b9ed5f48fb92a1c19543d67f29ee3bd43afee1ec1af6f7f9b4e3371beb8216201475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction without HTLCs, one output trimmed below maximum anchor amount
		chan.context.holder_dust_limit_satoshis = 330;
		chan.funding.value_to_self_msat = 9999800000;
		test_commitment_with_zero_fee!(
			"3045022100a13c79500a9b30eba7af13418816b54aea1da0bdf41c0aa10f53a29017080d5602201a11bcc10f99c4334f778ea94e83db63d2409ff10e9e95b4260ac0dba27a490f",
			"30440220706abbc90e9ab70a7e1f0f28b24baf2f105e49b7a41bf3b5e694f060806fc54402206020a5e51e437c027610a59f0252ac075dfb2b8e5b45f49149e9532935ba5e7a",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef8002c8000000000000000451024e73b895980000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0400483045022100a13c79500a9b30eba7af13418816b54aea1da0bdf41c0aa10f53a29017080d5602201a11bcc10f99c4334f778ea94e83db63d2409ff10e9e95b4260ac0dba27a490f014730440220706abbc90e9ab70a7e1f0f28b24baf2f105e49b7a41bf3b5e694f060806fc54402206020a5e51e437c027610a59f0252ac075dfb2b8e5b45f49149e9532935ba5e7a01475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction without HTLCs, one output trimmed above maximum anchor amount
		chan.context.holder_dust_limit_satoshis = 15000;
		chan.funding.value_to_self_msat = 9990000000;
		test_commitment_with_zero_fee!(
        "304402204042ce57689bb7e52af7fb9ec28d6610674ce00e5e438bb1119acfb91aad6386022065de45c4fe52d86249d80397f2c85e143550cb14b3de0cd1e6a54d0622a2bbd4",
        "30450221009fb4e444e9fe2d7db0f867704745c8ea2e4e1018b5986fd8cb9d9facdc1bb1be02202d6589a20ea8a8e3594eac3c99bad523139a36e313a66c6302e619786cb42396",
		"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef8002f0000000000000000451024e73706f980000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a040047304402204042ce57689bb7e52af7fb9ec28d6610674ce00e5e438bb1119acfb91aad6386022065de45c4fe52d86249d80397f2c85e143550cb14b3de0cd1e6a54d0622a2bbd4014830450221009fb4e444e9fe2d7db0f867704745c8ea2e4e1018b5986fd8cb9d9facdc1bb1be02202d6589a20ea8a8e3594eac3c99bad523139a36e313a66c6302e619786cb4239601475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction with all HTLCs above dust limit
		chan.context.holder_dust_limit_satoshis = 5000;
		chan.funding.value_to_self_msat = 8000000000;

		let htlc_in_preimage =
			preimage_from_hex("108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa");
		assert_eq!(
			payment_hash_from_hex(
				"23877c9093799487a8d49c7d6aaff7e06b9831c547400605252e7b07f7ae638a",
			),
			PaymentHash::from(htlc_in_preimage),
		);
		chan.context.pending_inbound_htlcs.extend([1, 2, 5].map(|id| InboundHTLCOutput {
			htlc_id: id,
			amount_msat: 5000000,
			cltv_expiry: 920150,
			payment_hash: PaymentHash::from(htlc_in_preimage),
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		}));

		chan.context.pending_outbound_htlcs.extend(
			[
				(5, "72c9386ba5a9d97b821d855930236d39c48dab5b1c2efe9ada44e2fbadcff983"),
				(8, "10b879729e8ddd44f2cfcf3cad6d62be535ca74e293c5ed4a59bd0dcbdad7ca1"),
				(13, "72c9386ba5a9d97b821d855930236d39c48dab5b1c2efe9ada44e2fbadcff983"),
			]
			.map(|(htlc_id, hash_str)| OutboundHTLCOutput {
				htlc_id,
				amount_msat: 25000000,
				cltv_expiry: 920141,
				payment_hash: payment_hash_from_hex(hash_str),
				state: OutboundHTLCState::Committed,
				source: HTLCSource::dummy(),
				skimmed_fee_msat: None,
				blinding_point: None,
				send_timestamp: None,
				hold_htlc: None,
				accountable: false,
			}),
		);

		test_commitment_with_zero_fee!(
			"30450221008e951c6305b8d661de280234019d664d7a706b6dc22c23f5488b6b141480d1c202207975f2c477d6fb26ac51b9aa81c1d2b35bb724cebbf21a63e5d7ef3d6e273baf",
			"3045022100ea978743401f2834d516ea434c0396c919e22465b4d2e359e61e6783535a89b30220475e2dbcc204016472b8eb9437e237a26ca102c1aa16812baa7ae522cc6291e8",
		"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800900000000000000000451024e73881300000000000022002075254560bb02c207015847abfda36d3a1b882e78c3f04b08325aac21c53989dc881300000000000022002075254560bb02c207015847abfda36d3a1b882e78c3f04b08325aac21c53989dc881300000000000022002075254560bb02c207015847abfda36d3a1b882e78c3f04b08325aac21c53989dca8610000000000002200200963a1f3e47b8d2a35664f70de49d3331b4499da201004868a9104271f0cd93ba8610000000000002200205b138be4da633f087be191275d3ce30828ae32d1630853fcbf66d22ca6fe2636a8610000000000002200205b138be4da633f087be191275d3ce30828ae32d1630853fcbf66d22ca6fe2636e8491e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152ea08ed780000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a04004830450221008e951c6305b8d661de280234019d664d7a706b6dc22c23f5488b6b141480d1c202207975f2c477d6fb26ac51b9aa81c1d2b35bb724cebbf21a63e5d7ef3d6e273baf01483045022100ea978743401f2834d516ea434c0396c919e22465b4d2e359e61e6783535a89b30220475e2dbcc204016472b8eb9437e237a26ca102c1aa16812baa7ae522cc6291e801475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {
			{0,
					"3045022100b82fff4e0652b305cc93f5f8e45362c55591c9ddb8e05a168c5df177ad8ff7ba022061827439423e660099d4c924257314656939b36180bf21b3a253bdd56f9f2b6b",
					"3044022024832648de0dc603b955b7b6a8ada64cc305affaf7357b018f481fb7e0c48c8d0220716568bee37589c5b67c941768fb10e10f48c1cc66b1128664455b99749a7c2a",
					"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c0135010000000000000000018813000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100b82fff4e0652b305cc93f5f8e45362c55591c9ddb8e05a168c5df177ad8ff7ba022061827439423e660099d4c924257314656939b36180bf21b3a253bdd56f9f2b6b83473044022024832648de0dc603b955b7b6a8ada64cc305affaf7357b018f481fb7e0c48c8d0220716568bee37589c5b67c941768fb10e10f48c1cc66b1128664455b99749a7c2a0120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503560a0eb175ac686800000000", Some(htlc_in_preimage) },
			{1,
					"3045022100c25f58229c0f9f985ef85235877268aad5da9cdcbceeb4425e668c97df2bfc920220053bca5957e55cdaa0734ba9a1b7a3eb0bdeced1d4496196d9d9de8ff1b20d2e",
					"3045022100d2f99843a7b29ec1b5044d2dc99f118d25157cdfc07213975a3e0bbc57f22e0a022000ac6b2dab53f34877c376d074d433c599721ea58c113bb7d2b7a540abbaab79",
					"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c0135020000000000000000018813000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100c25f58229c0f9f985ef85235877268aad5da9cdcbceeb4425e668c97df2bfc920220053bca5957e55cdaa0734ba9a1b7a3eb0bdeced1d4496196d9d9de8ff1b20d2e83483045022100d2f99843a7b29ec1b5044d2dc99f118d25157cdfc07213975a3e0bbc57f22e0a022000ac6b2dab53f34877c376d074d433c599721ea58c113bb7d2b7a540abbaab790120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503560a0eb175ac686800000000", Some(htlc_in_preimage) },
			{2,
					"3045022100948054ef219ec5af7494224f65ad6fab9cfd415d7260cb70a4719e99d421871f02205a41957a428b7820cef844c41cd06d8443f55953e000f4e40658175544a012ce",
					"3045022100efab186c9f98ff2326c56d26e0a4f0f58afc94fc241faae4334a944d277d7f3802207a79eb3f17fa874eca67c4245b670e51ca8d89d3bc02b2a8712ec28e71479eba",
					"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c0135030000000000000000018813000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100948054ef219ec5af7494224f65ad6fab9cfd415d7260cb70a4719e99d421871f02205a41957a428b7820cef844c41cd06d8443f55953e000f4e40658175544a012ce83483045022100efab186c9f98ff2326c56d26e0a4f0f58afc94fc241faae4334a944d277d7f3802207a79eb3f17fa874eca67c4245b670e51ca8d89d3bc02b2a8712ec28e71479eba0120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503560a0eb175ac686800000000", Some(htlc_in_preimage) },
			{3,
				"3045022100f2890a34be31987e4cc3e17f71d5174bb85121e57bb0105e8aa6793f6f057a42022000d0e11ffb3217bb91f1b8babb43e2726889cf3281bfaffa3b3b1c9970fa7109",
				"304402200373b0e0533fa0140ae10df40b93bb599920ce582d0a9d07398499554591659e02207f6ef44097b4e850bae0a4b5d6e0778a056e32ccd403ea88c62004d84e91a0af",
				"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c013504000000000000000001a861000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100f2890a34be31987e4cc3e17f71d5174bb85121e57bb0105e8aa6793f6f057a42022000d0e11ffb3217bb91f1b8babb43e2726889cf3281bfaffa3b3b1c9970fa71098347304402200373b0e0533fa0140ae10df40b93bb599920ce582d0a9d07398499554591659e02207f6ef44097b4e850bae0a4b5d6e0778a056e32ccd403ea88c62004d84e91a0af01008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914504170790db95d43716b136806e6a0fdf06e39e488ac68684d0a0e00", None::<PaymentPreimage> },
			{4,
				"30440220450536f38c6fde3e8777ad9c6d0a505ff44812de86fc82f0f2a0f4ce11f6ac7a022053306d3739ddd8a5cd8e2acba63b2076927200701762b314fb83faafcfcc3893",
				"3045022100e506e7ccb18b31fd3785477a3cfd885d7c21bf6eb9f5368cb321913208ae8e31022074c186967bf90a5583b46f445a6cb12fb6f2bf83805e048b486b8da29a553a46",
				"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c013505000000000000000001a861000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a05004730440220450536f38c6fde3e8777ad9c6d0a505ff44812de86fc82f0f2a0f4ce11f6ac7a022053306d3739ddd8a5cd8e2acba63b2076927200701762b314fb83faafcfcc389383483045022100e506e7ccb18b31fd3785477a3cfd885d7c21bf6eb9f5368cb321913208ae8e31022074c186967bf90a5583b46f445a6cb12fb6f2bf83805e048b486b8da29a553a4601008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914488ed834d26f1a1dc5e3428e1e1a214f743e6a2488ac68684d0a0e00", None::<PaymentPreimage> },
			{5,
				"3044022061b73271a1b6b5a1bd8e15c58b08320c72da0a1db19493abbfc6f74b5fa80c2c022030ff309d3413b9661fc8f8f2b5fd14bc733c239cc7ba8b971fd562263e62bf3b",
				"304402207559852cd036af82658949c28e4922f7351756616f8d04703e8060889b4b484e022050d997e1684826dc61bf0d88d9d08c01b8fcf67958ac7a177c320a1a70305fb0",
				"03000000000101c3b4fad51418c874498af12060d49477c154845040e3584104ae641c542c013506000000000000000001a861000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500473044022061b73271a1b6b5a1bd8e15c58b08320c72da0a1db19493abbfc6f74b5fa80c2c022030ff309d3413b9661fc8f8f2b5fd14bc733c239cc7ba8b971fd562263e62bf3b8347304402207559852cd036af82658949c28e4922f7351756616f8d04703e8060889b4b484e022050d997e1684826dc61bf0d88d9d08c01b8fcf67958ac7a177c320a1a70305fb001008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914488ed834d26f1a1dc5e3428e1e1a214f743e6a2488ac68684d0a0e00", None::<PaymentPreimage> }
			});

		// Commitment transaction with all HTLCs above dust limit and millisatoshi truncation
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		chan.context.pending_inbound_htlcs.extend([(7, 10000650), (9, 6000320)].map(
			|(htlc_id, amount_msat)| InboundHTLCOutput {
				htlc_id,
				amount_msat,
				cltv_expiry: 920150,
				payment_hash: PaymentHash::from(htlc_in_preimage),
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			},
		));

		chan.context.pending_outbound_htlcs.extend(
			[
				(5, 25000821, "72c9386ba5a9d97b821d855930236d39c48dab5b1c2efe9ada44e2fbadcff983"),
				(8, 25000210, "10b879729e8ddd44f2cfcf3cad6d62be535ca74e293c5ed4a59bd0dcbdad7ca1"),
			]
			.map(|(htlc_id, amount_msat, hash_str)| OutboundHTLCOutput {
				htlc_id,
				amount_msat,
				cltv_expiry: 920141,
				payment_hash: payment_hash_from_hex(hash_str),
				state: OutboundHTLCState::Committed,
				source: HTLCSource::dummy(),
				skimmed_fee_msat: None,
				blinding_point: None,
				send_timestamp: None,
				hold_htlc: None,
				accountable: false,
			}),
		);

		test_commitment_with_zero_fee!(
		"304402207077d60a004f42171b99c66b1b6b1799910d8f2cb72b0ef6d6500cd2f937c28a022016464954f0c05ae083bf559bc603c89f014006c44258d054a06ded667166a1f7",
		"3045022100cb78620afa0efd40d480286b59545e2e00379e78f6fb8c31d0d3659880176ed102201218323fbc8e0cd1184c7a164fad4cecb841f3eb75a3fc7d11208acbcb663865",
		"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800703000000000000000451024e73701700000000000022002075254560bb02c207015847abfda36d3a1b882e78c3f04b08325aac21c53989dc102700000000000022002075254560bb02c207015847abfda36d3a1b882e78c3f04b08325aac21c53989dca8610000000000002200200963a1f3e47b8d2a35664f70de49d3331b4499da201004868a9104271f0cd93ba8610000000000002200205b138be4da633f087be191275d3ce30828ae32d1630853fcbf66d22ca6fe2636ff451e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152eaae4e790000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a040047304402207077d60a004f42171b99c66b1b6b1799910d8f2cb72b0ef6d6500cd2f937c28a022016464954f0c05ae083bf559bc603c89f014006c44258d054a06ded667166a1f701483045022100cb78620afa0efd40d480286b59545e2e00379e78f6fb8c31d0d3659880176ed102201218323fbc8e0cd1184c7a164fad4cecb841f3eb75a3fc7d11208acbcb66386501475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {
		{0,
			"3045022100d53dbf9e7479d48322eda78cd96c0d3d6a53c55c7c0d629a2b11e1b1a02d6b95022031a06dda013ee5a26db181552499816de0a9786c71cbefd1614f8b2e6bcb9131",
			"304402204e4fd2e36058ed515f36cc609e636989fa89bf0b1d0e968fe642fcca7e2ceb1e022055a69e1e9be2799ae57ebae59792c9f50ca3943e6c154b4b3aabce6b08000930",
			"0300000000010122daaec93bca3ee6bee9c78cf7885e538a56d0cbd63e3df086bbac22b4f5455d010000000000000000017017000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100d53dbf9e7479d48322eda78cd96c0d3d6a53c55c7c0d629a2b11e1b1a02d6b95022031a06dda013ee5a26db181552499816de0a9786c71cbefd1614f8b2e6bcb91318347304402204e4fd2e36058ed515f36cc609e636989fa89bf0b1d0e968fe642fcca7e2ceb1e022055a69e1e9be2799ae57ebae59792c9f50ca3943e6c154b4b3aabce6b080009300120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503560a0eb175ac686800000000", Some(htlc_in_preimage) },
		{1,
			"304402206556f3ae8fb62fd764f1a65fcc238bfc7cd629872c52ba7ee7b91e34aed4f9de022008545d9f5477371f940d8719270cc1b22d04497f53a97bf75dfb6a9ec5e5b49e",
			"304402205aa6b8143ef46e644157c4f4ad2ff439ae3c2e0cd76c2d3050aa6a1f5a31d33d022072f430949c2996233c5e832c3957f4f9bbf5586af3d62ebf3c0621cf92511b1a",
			"0300000000010122daaec93bca3ee6bee9c78cf7885e538a56d0cbd63e3df086bbac22b4f5455d020000000000000000011027000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a050047304402206556f3ae8fb62fd764f1a65fcc238bfc7cd629872c52ba7ee7b91e34aed4f9de022008545d9f5477371f940d8719270cc1b22d04497f53a97bf75dfb6a9ec5e5b49e8347304402205aa6b8143ef46e644157c4f4ad2ff439ae3c2e0cd76c2d3050aa6a1f5a31d33d022072f430949c2996233c5e832c3957f4f9bbf5586af3d62ebf3c0621cf92511b1a0120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503560a0eb175ac686800000000", Some(htlc_in_preimage) },
		{2,
			"30450221009d775b6e196693171a41c69337de17bd6c7846dd677d0f9db8595faedb3f621f022060eb980ee28effaa38515b31691ec522fef90db0f6b83c07cf3cf3aebc1302c0",
			"3045022100e93e04871634a1eded25a6721bb6005787e92cfea09831f7af99433891d5373202204ec63ff8fd536518eca98e068d05d562d7be9465cb4d72a52a35308a4b3d8430",
			"0300000000010122daaec93bca3ee6bee9c78cf7885e538a56d0cbd63e3df086bbac22b4f5455d03000000000000000001a861000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a05004830450221009d775b6e196693171a41c69337de17bd6c7846dd677d0f9db8595faedb3f621f022060eb980ee28effaa38515b31691ec522fef90db0f6b83c07cf3cf3aebc1302c083483045022100e93e04871634a1eded25a6721bb6005787e92cfea09831f7af99433891d5373202204ec63ff8fd536518eca98e068d05d562d7be9465cb4d72a52a35308a4b3d843001008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914504170790db95d43716b136806e6a0fdf06e39e488ac68684d0a0e00", None::<PaymentPreimage> },
		{3,
			"3045022100c86ebf7f229be7b621a34a3fac39cfe20ea6b26e078eca782c136e635077b47a02205866ca91ef3eb8bc8dd8190c25d8a70dd101b067cc038d367ef2ee5a67c1beea",
			"304402203f81e6064b5a57bdc9a8759a0906dd8ee767063878f10133c435198c89c575a2022045d4e28f14aad0be1f03e43b3c6bd994d95b18b7ee979b4166c50659d4c02fa6",
			"0300000000010122daaec93bca3ee6bee9c78cf7885e538a56d0cbd63e3df086bbac22b4f5455d04000000000000000001a861000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100c86ebf7f229be7b621a34a3fac39cfe20ea6b26e078eca782c136e635077b47a02205866ca91ef3eb8bc8dd8190c25d8a70dd101b067cc038d367ef2ee5a67c1beea8347304402203f81e6064b5a57bdc9a8759a0906dd8ee767063878f10133c435198c89c575a2022045d4e28f14aad0be1f03e43b3c6bd994d95b18b7ee979b4166c50659d4c02fa601008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914488ed834d26f1a1dc5e3428e1e1a214f743e6a2488ac68684d0a0e00", None::<PaymentPreimage> }
		});

		// Commitment transaction with dust HTLCs below maximum anchor amount
		chan.context.holder_dust_limit_satoshis = 1000;
		chan.funding.value_to_self_msat = 8000000000;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		let htlc_0_in_preimage =
			preimage_from_hex("d3ad493d19860e4744491cf0795c0bc96a8e2a49ebb30afadae7a7d077aa93b2");
		let htlc_0_in_hash = PaymentHash::from(htlc_0_in_preimage);
		assert_eq!(
			payment_hash_from_hex(
				"ffa4f37b6d7dc03fecaaed8d36ebbea6d199e820e386e4549a69ce733f39f29f",
			),
			htlc_0_in_hash,
			"test vector hash does not match ours",
		);
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 0,
			amount_msat: 100000,
			cltv_expiry: 920125,
			payment_hash: htlc_0_in_hash,
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		let htlc_1_in_preimage =
			preimage_from_hex("5591b96c0a6a03f51c27bfa658149260bd2fe5e2ce83130ce50d0229a3a947c5");
		let htlc_1_in_hash = PaymentHash::from(htlc_1_in_preimage);
		assert_eq!(
			payment_hash_from_hex(
				"72c9386ba5a9d97b821d855930236d39c48dab5b1c2efe9ada44e2fbadcff983",
			),
			htlc_1_in_hash,
			"test vector hash does not match ours",
		);
		chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
			htlc_id: 1,
			amount_msat: 49900000,
			cltv_expiry: 920125,
			payment_hash: htlc_1_in_hash,
			state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
		});

		chan.context.pending_outbound_htlcs.extend(
			[(0, 10000000), (1, 130000), (2, 10000000)].map(|(htlc_id, amount_msat)| {
				OutboundHTLCOutput {
					htlc_id,
					amount_msat,
					cltv_expiry: 920140,
					payment_hash: payment_hash_from_hex(
						"29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf",
					),
					state: OutboundHTLCState::Committed,
					source: HTLCSource::dummy(),
					skimmed_fee_msat: None,
					blinding_point: None,
					send_timestamp: None,
					hold_htlc: None,
					accountable: false,
				}
			}),
		);

		test_commitment_with_zero_fee!(
		"3045022100cb7b6ae16b80c1ad74baea6f37be3581ca60915da75a03be3b377493f3359cc302203b591047f669cce31215c8a5a6039d5fd8dbfd8d6b53af39a619e6541d6bcf31",
		"3045022100a661444a0800fe5e8bf9ecdef3631610e834485503b8e58d64d08ed5e88ebb2d0220248944d134cadf36cef90d05785ece9432727e81f0f66958a903baa0d69061cd",
		"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef8006e6000000000000000451024e73102700000000000022002081cd2904fc5581e6459d9375384af1223e6bd4fd112f3505e87b81e622a48cb7102700000000000022002081cd2904fc5581e6459d9375384af1223e6bd4fd112f3505e87b81e622a48cb7ecc20000000000002200207c2edfefe2690c02efde0c461b8a9283ed2a68968109306be4cb5fa848bd7a7630c11d0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152ea5ec3790000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0400483045022100cb7b6ae16b80c1ad74baea6f37be3581ca60915da75a03be3b377493f3359cc302203b591047f669cce31215c8a5a6039d5fd8dbfd8d6b53af39a619e6541d6bcf3101483045022100a661444a0800fe5e8bf9ecdef3631610e834485503b8e58d64d08ed5e88ebb2d0220248944d134cadf36cef90d05785ece9432727e81f0f66958a903baa0d69061cd01475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {
			{0,
				"30450221009beeb028f6de6f925a986f3aaac7931bd46779b5a2dc8e82ae0509cf0174468002205a2761d34b276752f7f6e62c013c9509104a831df1f4b91a692bb8ad48285d31",
				"3045022100c04dd0b08fd50bfc921de2a5d09840aab97b116e95ffd09cc11470404280be1202204aee1cd187f0074c5b80bae98981d232168daba5bde67adc7539b1a55a5a6709",
				"03000000000101d8211cfec4c28b189edcf7b12b739bfbc0f77e44cc6fab67e50fa23cc78481c5010000000000000000011027000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a05004830450221009beeb028f6de6f925a986f3aaac7931bd46779b5a2dc8e82ae0509cf0174468002205a2761d34b276752f7f6e62c013c9509104a831df1f4b91a692bb8ad48285d3183483045022100c04dd0b08fd50bfc921de2a5d09840aab97b116e95ffd09cc11470404280be1202204aee1cd187f0074c5b80bae98981d232168daba5bde67adc7539b1a55a5a670901008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a91489baf9f76be304292b0314ffa9c61eb794b05dd188ac68684c0a0e00", None::<PaymentPreimage> },
			{1,
				"304402203a6ed1dc27298cfb030a5ff0f237b5288e263bd3cfe13ced890f3559e7c25db10220713167cc374f850a2f414dd8988f87cbfe978ba56b8c5cf690aa3c2d357a174c",
				"3045022100c2f636b397f0fd6731b04323a0743aee902f01ac2e8bdac72548ab5380fecd0f02206ee5c57fac4c5255018bc687ae46a97a9781b7d87722d3c73b8bc93d951f713f",
				"03000000000101d8211cfec4c28b189edcf7b12b739bfbc0f77e44cc6fab67e50fa23cc78481c5020000000000000000011027000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a050047304402203a6ed1dc27298cfb030a5ff0f237b5288e263bd3cfe13ced890f3559e7c25db10220713167cc374f850a2f414dd8988f87cbfe978ba56b8c5cf690aa3c2d357a174c83483045022100c2f636b397f0fd6731b04323a0743aee902f01ac2e8bdac72548ab5380fecd0f02206ee5c57fac4c5255018bc687ae46a97a9781b7d87722d3c73b8bc93d951f713f01008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a91489baf9f76be304292b0314ffa9c61eb794b05dd188ac68684c0a0e00", None::<PaymentPreimage> },
			{2,
				"3045022100bbafdb3eeb4ab737859798753e0685f203294b6225c1300c9db6867a6f5fde180220769ca281abe51e93d707262ab3f45c54f5ec0ad3529836de0536b24e635e1c9f",
				"304402200f60ba0673e03a25cd8ab2f2d8fe4e0bc3ac7ffafe932e7a76afb3be7189b4f50220541a02e557d7ff2ccf0f5be4fa22291d07ecf67d8666dffba55e76ecbb5b9bf9",
				"03000000000101d8211cfec4c28b189edcf7b12b739bfbc0f77e44cc6fab67e50fa23cc78481c503000000000000000001ecc2000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100bbafdb3eeb4ab737859798753e0685f203294b6225c1300c9db6867a6f5fde180220769ca281abe51e93d707262ab3f45c54f5ec0ad3529836de0536b24e635e1c9f8347304402200f60ba0673e03a25cd8ab2f2d8fe4e0bc3ac7ffafe932e7a76afb3be7189b4f50220541a02e557d7ff2ccf0f5be4fa22291d07ecf67d8666dffba55e76ecbb5b9bf901205591b96c0a6a03f51c27bfa658149260bd2fe5e2ce83130ce50d0229a3a947c58b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914488ed834d26f1a1dc5e3428e1e1a214f743e6a2488527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae6775033d0a0eb175ac686800000000",
				Some(htlc_1_in_preimage) }
		});

		// Commitment transaction with similar dust HTLCs below maximum anchor amount
		chan.context.holder_dust_limit_satoshis = 546;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		chan.context.pending_inbound_htlcs.extend([(0, htlc_0_in_hash), (1, htlc_1_in_hash)].map(
			|(htlc_id, payment_hash)| InboundHTLCOutput {
				htlc_id,
				amount_msat: 30000,
				payment_hash,
				cltv_expiry: 920125,
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			},
		));

		chan.context.pending_outbound_htlcs.extend(
			[
				(0, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf"),
				(1, "1a04764fd402b5557cba89ec3c4d8931b0225d6436923c65c079ce64a55084c4"),
				(2, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf"),
				(3, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf"),
			]
			.map(|(id, hash)| OutboundHTLCOutput {
				htlc_id: id,
				amount_msat: 30000,
				cltv_expiry: 920125,
				payment_hash: payment_hash_from_hex(hash),
				state: OutboundHTLCState::Committed,
				source: HTLCSource::dummy(),
				skimmed_fee_msat: None,
				blinding_point: None,
				send_timestamp: None,
				hold_htlc: None,
				accountable: false,
			}),
		);

		test_commitment_with_zero_fee!(
			"3044022034f22696dd7501d65fc117af3edcfed535eb301317fe35eef08658b571fca4d0022030ff6276cff9e22968f8b08f92a1d4f2c37fe4da29de095df4841d32bdaa501b",
			"30450221009c820c376715329110045b3cf90f59838fd2f86b16774cb5ccccbd6a62830d9602205f2d970bef2589a5e37035937ab7db0461223e429b943b38ecf577e32b7b4572",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef8003b4000000000000000451024e7344841e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152ea88117a0000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0400473044022034f22696dd7501d65fc117af3edcfed535eb301317fe35eef08658b571fca4d0022030ff6276cff9e22968f8b08f92a1d4f2c37fe4da29de095df4841d32bdaa501b014830450221009c820c376715329110045b3cf90f59838fd2f86b16774cb5ccccbd6a62830d9602205f2d970bef2589a5e37035937ab7db0461223e429b943b38ecf577e32b7b457201475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction with millisatoshi dust HTLCs adding to less than 1 satoshi"
		chan.context.holder_dust_limit_satoshis = 330;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		chan.context.pending_inbound_htlcs.extend([(0, htlc_0_in_hash)].map(
			|(htlc_id, payment_hash)| InboundHTLCOutput {
				htlc_id,
				amount_msat: 29525,
				payment_hash,
				cltv_expiry: 920125,
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			},
		));

		chan.context.pending_outbound_htlcs.extend(
			[(0, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf")].map(
				|(id, hash)| OutboundHTLCOutput {
					htlc_id: id,
					amount_msat: 21474,
					cltv_expiry: 920125,
					payment_hash: payment_hash_from_hex(hash),
					state: OutboundHTLCState::Committed,
					source: HTLCSource::dummy(),
					skimmed_fee_msat: None,
					blinding_point: None,
					send_timestamp: None,
					hold_htlc: None,
					accountable: false,
				},
			),
		);

		test_commitment_with_zero_fee!(
			"304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177",
			"30440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800334000000000000000451024e7362841e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152eaea117a0000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a040047304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177014730440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d01475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction with millisatoshi dust HTLCs adding to 1 satoshi"
		chan.context.holder_dust_limit_satoshis = 330;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		chan.context.pending_inbound_htlcs.extend([(0, htlc_0_in_hash)].map(
			|(htlc_id, payment_hash)| InboundHTLCOutput {
				htlc_id,
				amount_msat: 29525,
				payment_hash,
				cltv_expiry: 920125,
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			},
		));

		chan.context.pending_outbound_htlcs.extend(
			[(0, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf")].map(
				|(id, hash)| OutboundHTLCOutput {
					htlc_id: id,
					amount_msat: 21475,
					cltv_expiry: 920125,
					payment_hash: payment_hash_from_hex(hash),
					state: OutboundHTLCState::Committed,
					source: HTLCSource::dummy(),
					skimmed_fee_msat: None,
					blinding_point: None,
					send_timestamp: None,
					hold_htlc: None,
					accountable: false,
				},
			),
		);

		test_commitment_with_zero_fee!(
			"304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177",
			"30440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800334000000000000000451024e7362841e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152eaea117a0000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a040047304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177014730440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d01475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction with millisatoshi dust HTLCs adding to more than 1 satoshi"
		chan.context.holder_dust_limit_satoshis = 330;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		chan.context.pending_inbound_htlcs.extend([(0, htlc_0_in_hash)].map(
			|(htlc_id, payment_hash)| InboundHTLCOutput {
				htlc_id,
				amount_msat: 29753,
				payment_hash,
				cltv_expiry: 920125,
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			},
		));

		chan.context.pending_outbound_htlcs.extend(
			[(0, "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf")].map(
				|(id, hash)| OutboundHTLCOutput {
					htlc_id: id,
					amount_msat: 21712,
					cltv_expiry: 920125,
					payment_hash: payment_hash_from_hex(hash),
					state: OutboundHTLCState::Committed,
					source: HTLCSource::dummy(),
					skimmed_fee_msat: None,
					blinding_point: None,
					send_timestamp: None,
					hold_htlc: None,
					accountable: false,
				},
			),
		);

		test_commitment_with_zero_fee!(
			"304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177",
			"30440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d",
			"03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef800334000000000000000451024e7362841e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152eaea117a0000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a040047304402201368dc415e11647edbfc1faaaccbe4717e5fdb88c4220a0bb19969781c9f757f02203fad3a7578fcfdc428b527b97f918b639ff07941b3b42c44f58b1364fdc57177014730440220338a338e0d477b63d2a7a00baca06c45b74bdd63d02e7d198cd8435180e9317e022014d0b95c9fde3409678417ee1a71d1d4d755f28db66a83eb10bea56de83d628d01475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {});

		// Commitment transaction with dust HTLCs above maximum anchor amount
		chan.context.holder_dust_limit_satoshis = 2500;
		chan.funding.value_to_self_msat = 8000000000;
		chan.context.pending_inbound_htlcs.clear();
		chan.context.pending_outbound_htlcs.clear();

		let htlc_2_in_preimage =
			preimage_from_hex("108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa");
		let htlc_2_in_hash = PaymentHash::from(htlc_2_in_preimage);
		assert_eq!(
			payment_hash_from_hex(
				"23877c9093799487a8d49c7d6aaff7e06b9831c547400605252e7b07f7ae638a",
			),
			htlc_2_in_hash,
		);
		chan.context.pending_inbound_htlcs.extend(
			[
				(0, 2000000, 920125, htlc_0_in_hash),
				(1, 5000000, 920130, htlc_0_in_hash),
				(2, 5000000, 920130, htlc_2_in_hash),
			]
			.map(|(id, amount_msat, cltv_expiry, payment_hash)| InboundHTLCOutput {
				htlc_id: id,
				amount_msat,
				cltv_expiry,
				payment_hash,
				state: InboundHTLCState::Committed { update_add_htlc: dummy_inbound_update_add() },
			}),
		);

		let htlc_0_out_hash = "1a04764fd402b5557cba89ec3c4d8931b0225d6436923c65c079ce64a55084c4";
		let htlc_1_out_hash = "29a74a69c5941d402838f7e1a95c2b2ec534d79524b2582f48df7bc519ebaecf";
		let htlc_2_out_hash = "10b879729e8ddd44f2cfcf3cad6d62be535ca74e293c5ed4a59bd0dcbdad7ca1";

		chan.context.pending_outbound_htlcs.extend(
			[
				(0, 1000000, 920125, htlc_0_out_hash),
				(1, 1000000, 920130, htlc_1_out_hash),
				(2, 10000000, 920130, htlc_2_out_hash),
			]
			.map(|(id, amount_msat, cltv_expiry, hash)| OutboundHTLCOutput {
				htlc_id: id,
				amount_msat,
				cltv_expiry,
				payment_hash: payment_hash_from_hex(hash),
				state: OutboundHTLCState::Committed,
				source: HTLCSource::dummy(),
				skimmed_fee_msat: None,
				blinding_point: None,
				send_timestamp: None,
				hold_htlc: None,
				accountable: false,
			}),
		);

		test_commitment_with_zero_fee!(
			  "3045022100f706457b6f58634a64d86a403b622018d1cdf08064f08eaaf90ed47cbdfc81f002200b23d77b8151d0e907850d313b87cf53f0a1e8aef871cbb5ec3ef7f3af513261",
			  "3045022100cf3f7201781764693b8bb2db1a703c62fe9cb992103d4d950e9d1806e2e4c49202203993f5bfcc1f91617d48f22a10f2400ca298f42499d8389d4396bcad8750e883",
			  "03000000000101ae1e3c841378cf9e4c383bfdd033d4b3c6945e0587ff16635a00b347eea2704b0100000000340fef8006f0000000000000000451024e7388130000000000002200202cb7b4a1ac1ca2aa06918f6933a9bf3a6ab777abfca18ac22fb4eeec587faf048813000000000000220020fd9f3b68e5a818a53f020ab09d1c956ead78f28b3c22950dc0d73568f797c92210270000000000002200200963a1f3e47b8d2a35664f70de49d3331b4499da201004868a9104271f0cd93ba0551e0000000000160014f2123f1a4b67887f2e5f02eda73e6327010152ea20e3790000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0400483045022100f706457b6f58634a64d86a403b622018d1cdf08064f08eaaf90ed47cbdfc81f002200b23d77b8151d0e907850d313b87cf53f0a1e8aef871cbb5ec3ef7f3af51326101483045022100cf3f7201781764693b8bb2db1a703c62fe9cb992103d4d950e9d1806e2e4c49202203993f5bfcc1f91617d48f22a10f2400ca298f42499d8389d4396bcad8750e88301475221027eb9596a68740445fb151ff37d5422e7f65f2c497c90fda63e738eb606c15bd62103bbc16dc8851bece603322f06b3c8da329401b7be7e9fdd3f3090ad19aed0807052aec50fbb20", {
				{0,
					"3044022072f786f54d93d9b1780bd3c605a434a2ae097852c6af75b18a23ea3e7cb995de02205608d310544bed398c406cf8f6cdeadbf119a8808c38415dbc93c82733168fc6",
					"3045022100e5e66a86053e6adda1b02786d9e8b9b7057026b8d81263fe5414d6b7660e70c7022055ff89300da995e2c8122e997338dac2d5ea2f526dcb243b9e7c1eb380155e10",
					"0300000000010142bb3321b077161ea560097e1b149edef504e00f1e2c6a77bbe4ad2aed6fde07010000000000000000018813000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500473044022072f786f54d93d9b1780bd3c605a434a2ae097852c6af75b18a23ea3e7cb995de02205608d310544bed398c406cf8f6cdeadbf119a8808c38415dbc93c82733168fc683483045022100e5e66a86053e6adda1b02786d9e8b9b7057026b8d81263fe5414d6b7660e70c7022055ff89300da995e2c8122e997338dac2d5ea2f526dcb243b9e7c1eb380155e100120d3ad493d19860e4744491cf0795c0bc96a8e2a49ebb30afadae7a7d077aa93b28b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a91416a189e9fcfe9edc8c6930da3dd87cebf44045a388527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503420a0eb175ac686800000000", Some(htlc_0_in_preimage) },
				{1,
					"30440220444371784d52a13dedec1baedd0a5f10cc78727a873614cf6981696e0ef9d28502202961336e7e0cbb530c4e5dda0a628bc21b5ce8e3f1e6274bd7ee20cf7b697421",
					"304402205b1693a32569a757d0928c163aae56a3986e3d53741ba0a9db5aac1289752aa3022002c8ef3e377a2461800e98cbfc40b31511d39e02473152943d959dcfd55e7c9e",
					"0300000000010142bb3321b077161ea560097e1b149edef504e00f1e2c6a77bbe4ad2aed6fde07020000000000000000018813000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a05004730440220444371784d52a13dedec1baedd0a5f10cc78727a873614cf6981696e0ef9d28502202961336e7e0cbb530c4e5dda0a628bc21b5ce8e3f1e6274bd7ee20cf7b6974218347304402205b1693a32569a757d0928c163aae56a3986e3d53741ba0a9db5aac1289752aa3022002c8ef3e377a2461800e98cbfc40b31511d39e02473152943d959dcfd55e7c9e0120108cd7067c8ed6f3734b7b67ec153cfa83c40755b75c65e414e934099e6993aa8b76a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c8201208763a914f4c8e88504a23ed3e390ea80300c834f0eb79a6c88527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae677503420a0eb175ac686800000000", Some(htlc_2_in_preimage) },
				{2,
					"3045022100eee7c19343ad58d9381a808fcd14af0c1e05bd56bd16c25c5ad8980af68b2df9022046acc611280afabcd82ef4a256d1f42be6618bc12d83bcd138141fb4915d256f",
					"3045022100e6c8d81693cd3a03db0777b31e9318f8b8eb5f275817116dce8a72064d096bee02206439ddcac93a2756e1079e955245e2ac1924d874ba8388de9d497e4286cc20cb",
					"0300000000010142bb3321b077161ea560097e1b149edef504e00f1e2c6a77bbe4ad2aed6fde07030000000000000000011027000000000000220020f2d298ffcfd6d899a3abada37bfc6f42ce0b7b66f3e39e903e8419ac97dca75a0500483045022100eee7c19343ad58d9381a808fcd14af0c1e05bd56bd16c25c5ad8980af68b2df9022046acc611280afabcd82ef4a256d1f42be6618bc12d83bcd138141fb4915d256f83483045022100e6c8d81693cd3a03db0777b31e9318f8b8eb5f275817116dce8a72064d096bee02206439ddcac93a2756e1079e955245e2ac1924d874ba8388de9d497e4286cc20cb01008576a914ef8968bbfe34ad740642784d7b1efaebfd5b23ec8763ac672103d8507a026fb30bcd48ee9c765c7346470d0d397661d43dd2eb601f661ab92a0b7c820120876475527c2103c26117339025855b87deda5e138d438b2098881a5e6f81f72a60310faef473c652ae67a914504170790db95d43716b136806e6a0fdf06e39e488ac6868420a0e00", None::<PaymentPreimage>}
		});
	}

	#[test]
	#[rustfmt::skip]
	fn test_per_commitment_secret_gen() {
		// Test vectors from BOLT 3 Appendix D:

		let mut seed = [0; 32];
		seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
		assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
		           <Vec<u8>>::from_hex("02a40c85b6f28da08dfdbe0926c53fab2de6d28c10301f8f7c4073d5e42e3148").unwrap()[..]);

		seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap());
		assert_eq!(chan_utils::build_commitment_secret(&seed, 281474976710655),
		           <Vec<u8>>::from_hex("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()[..]);

		assert_eq!(chan_utils::build_commitment_secret(&seed, 0xaaaaaaaaaaa),
		           <Vec<u8>>::from_hex("56f4008fb007ca9acf0e15b054d5c9fd12ee06cea347914ddbaed70d1c13a528").unwrap()[..]);

		assert_eq!(chan_utils::build_commitment_secret(&seed, 0x555555555555),
		           <Vec<u8>>::from_hex("9015daaeb06dba4ccc05b91b2f73bd54405f2be9f217fbacd3c5ac2e62327d31").unwrap()[..]);

		seed[0..32].clone_from_slice(&<Vec<u8>>::from_hex("0101010101010101010101010101010101010101010101010101010101010101").unwrap());
		assert_eq!(chan_utils::build_commitment_secret(&seed, 1),
		           <Vec<u8>>::from_hex("915c75942a26bb3a433a8ce2cb0427c29ec6c1775cfc78328b57f6ba7bfeaa9c").unwrap()[..]);
	}

	#[test]
	#[rustfmt::skip]
	fn test_key_derivation() {
		// Test vectors from BOLT 3 Appendix E:
		let secp_ctx = Secp256k1::new();

		let base_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap();
		let per_commitment_secret = SecretKey::from_slice(&<Vec<u8>>::from_hex("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();

		let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret);
		assert_eq!(base_point.serialize()[..], <Vec<u8>>::from_hex("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]);

		let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
		assert_eq!(per_commitment_point.serialize()[..], <Vec<u8>>::from_hex("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]);

		assert_eq!(chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &base_secret),
				SecretKey::from_slice(&<Vec<u8>>::from_hex("cbced912d3b21bf196a766651e436aff192362621ce317704ea2f75d87e7be0f").unwrap()[..]).unwrap());

		assert_eq!(RevocationKey::from_basepoint(&secp_ctx, &RevocationBasepoint::from(base_point), &per_commitment_point).to_public_key().serialize()[..],
				<Vec<u8>>::from_hex("02916e326636d19c33f13e8c0c3a03dd157f332f3e99c317c141dd865eb01f8ff0").unwrap()[..]);

		assert_eq!(chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_secret, &base_secret),
				SecretKey::from_slice(&<Vec<u8>>::from_hex("d09ffff62ddb2297ab000cc85bcb4283fdeb6aa052affbc9dddcf33b61078110").unwrap()[..]).unwrap());
	}

	#[test]
	#[rustfmt::skip]
	fn test_waiting_for_batch() {
		let test_est = TestFeeEstimator::new(15000);
		let feeest = LowerBoundedFeeEstimator::new(&test_est);
		let logger = TestLogger::new();
		let secp_ctx = Secp256k1::new();
		let seed = [42; 32];
		let network = Network::Testnet;
		let best_block = BlockLocator::from_network(network);
		let chain_hash = ChainHash::using_genesis_block(network);
		let keys_provider = TestKeysInterface::new(&seed, network);

		let mut config = UserConfig::default();
		// Set trust_own_funding_0conf while ensuring we don't send channel_ready for a
		// channel in a batch before all channels are ready.
		config.channel_handshake_limits.trust_own_funding_0conf = true;

		// Create a channel from node a to node b that will be part of batch funding.
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
		let mut node_a_chan = OutboundV1Channel::<&TestKeysInterface>::new(
			&feeest,
			&&keys_provider,
			&&keys_provider,
			node_b_node_id,
			&channelmanager::provided_init_features(&config),
			10000000,
			100000,
			42,
			&config,
			0,
			42,
			None,
			&logger,
			None,
		).unwrap();

		let open_channel_msg = node_a_chan.get_open_channel(ChainHash::using_genesis_block(network), &&logger).unwrap();
		let node_b_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[7; 32]).unwrap());
		let mut node_b_chan = InboundV1Channel::<&TestKeysInterface>::new(
			&feeest,
			&&keys_provider,
			&&keys_provider,
			node_b_node_id,
			&channelmanager::provided_channel_type_features(&config),
			&channelmanager::provided_init_features(&config),
			&open_channel_msg,
			7,
			&config,
			0,
			&&logger,
			// Allow node b to send a 0conf channel_ready.
			Some(TrustedChannelFeatures::ZeroConf),
		).unwrap();

		let accept_channel_msg = node_b_chan.accept_inbound_channel(&&logger).unwrap();
		node_a_chan.accept_channel(
			&accept_channel_msg,
			&config.channel_handshake_limits,
			&channelmanager::provided_init_features(&config),
		).unwrap();

		// Fund the channel with a batch funding transaction.
		let output_script = node_a_chan.funding.get_funding_redeemscript();
		let tx = Transaction {
			version: Version::ONE,
			lock_time: LockTime::ZERO,
			input: Vec::new(),
			output: vec![
				TxOut {
					value: Amount::from_sat(10000000), script_pubkey: output_script.clone(),
				},
				TxOut {
					value: Amount::from_sat(10000000), script_pubkey: Builder::new().into_script(),
				},
			]};
		let funding_outpoint = OutPoint{ txid: tx.compute_txid(), index: 0 };
		let funding_created_msg = node_a_chan.get_funding_created(
			tx.clone(), funding_outpoint, true, &&logger,
		).map_err(|_| ()).unwrap();
		let (mut node_b_chan, funding_signed_msg, _) = node_b_chan.funding_created(
			&funding_created_msg.unwrap(),
			best_block,
			&&keys_provider,
			&&logger,
		).map_err(|_| ()).unwrap();
		let node_b_updates = node_b_chan.monitor_updating_restored(
			&WithChannelContext::from(&logger, &node_b_chan.context, None),
			&&keys_provider,
			chain_hash,
			&config,
			0,
			|_| unreachable!()
		);

		// Receive funding_signed, but the channel will be configured to hold sending channel_ready and
		// broadcasting the funding transaction until the batch is ready.
		let res = node_a_chan.funding_signed(
			&funding_signed_msg.unwrap(), best_block, &&keys_provider, &&logger,
		);
		let (mut node_a_chan, _) = if let Ok(res) = res { res } else { panic!(); };
		let node_a_updates = node_a_chan.monitor_updating_restored(
			&WithChannelContext::from(&logger, &node_a_chan.context, None),
			&&keys_provider,
			chain_hash,
			&config,
			0,
			|_| unreachable!()
		);
		// Our channel_ready shouldn't be sent yet, even with trust_own_funding_0conf set,
		// as the funding transaction depends on all channels in the batch becoming ready.
		assert!(node_a_updates.channel_ready.is_none());
		assert!(node_a_updates.funding_broadcastable.is_none());
		assert_eq!(node_a_chan.context.channel_state, ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH));

		// It is possible to receive a 0conf channel_ready from the remote node.
		node_a_chan.channel_ready(
			&node_b_updates.channel_ready.unwrap(),
			&&keys_provider,
			chain_hash,
			&config,
			&best_block,
			&&logger,
		).unwrap();
		assert_eq!(
			node_a_chan.context.channel_state,
			ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::WAITING_FOR_BATCH | AwaitingChannelReadyFlags::THEIR_CHANNEL_READY)
		);

		// Clear the ChannelState::WaitingForBatch only when called by ChannelManager.
		node_a_chan.set_batch_ready();
		assert_eq!(node_a_chan.context.channel_state, ChannelState::AwaitingChannelReady(AwaitingChannelReadyFlags::THEIR_CHANNEL_READY));
		assert!(node_a_chan.check_get_channel_ready(0, &&logger).is_some());
	}
}