/// [`msgs::RevokeAndACK`] or [`msgs::ChannelReestablish`] message before we attempt to disconnect
/// them.
///
-/// See [`Channel::sent_message_awaiting_response`] for more information.
+/// See [`ChannelContext::sent_message_awaiting_response`] for more information.
pub(crate) const DISCONNECT_PEER_AWAITING_RESPONSE_TICKS: usize = 2;
struct PendingChannelMonitorUpdate {
(2, blocked, required),
});
-// TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
-// has been completed, and then turn into a Channel to get compiler-time enforcement of things like
-// calling channel_id() before we're set up or things like get_outbound_funding_signed on an
-// inbound channel.
-//
-// Holder designates channel data owned for the benefice of the user client.
-// Counterparty designates channel data owned by the another channel participant entity.
-pub(super) struct Channel<Signer: ChannelSigner> {
+/// Contains everything about the channel including state, and various flags.
+pub(super) struct ChannelContext<Signer: ChannelSigner> {
config: LegacyChannelConfig,
// Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
pending_monitor_updates: Vec<PendingChannelMonitorUpdate>,
}
+// TODO: We should refactor this to be an Inbound/OutboundChannel until initial setup handshaking
+// has been completed, and then turn into a Channel to get compiler-time enforcement of things like
+// calling channel_id() before we're set up or things like get_outbound_funding_signed on an
+// inbound channel.
+//
+// Holder designates channel data owned for the benefit of the user client.
+// Counterparty designates channel data owned by the another channel participant entity.
+pub(super) struct Channel<Signer: ChannelSigner> {
+ pub context: ChannelContext<Signer>,
+}
+
#[cfg(any(test, fuzzing))]
struct CommitmentTxInfoCached {
fee: u64,
}
pub(crate) fn opt_anchors(&self) -> bool {
- self.channel_transaction_parameters.opt_anchors.is_some()
+ self.context.channel_transaction_parameters.opt_anchors.is_some()
}
fn get_initial_channel_type(config: &UserConfig, their_features: &InitFeatures) -> ChannelTypeFeatures {
/// 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.
pub(crate) fn maybe_handle_error_without_close(&mut self, chain_hash: BlockHash) -> Result<msgs::OpenChannel, ()> {
- if !self.is_outbound() || self.channel_state != ChannelState::OurInitSent as u32 { return Err(()); }
- if self.channel_type == ChannelTypeFeatures::only_static_remote_key() {
+ if !self.is_outbound() || self.context.channel_state != ChannelState::OurInitSent as u32 { return Err(()); }
+ if self.context.channel_type == ChannelTypeFeatures::only_static_remote_key() {
// We've exhausted our options
return Err(());
}
// checks whether the counterparty supports every feature, this would only happen if the
// counterparty is advertising the feature, but rejecting channels proposing the feature for
// whatever reason.
- if self.channel_type.supports_anchors_zero_fee_htlc_tx() {
- self.channel_type.clear_anchors_zero_fee_htlc_tx();
- assert!(self.channel_transaction_parameters.opt_non_zero_fee_anchors.is_none());
- self.channel_transaction_parameters.opt_anchors = None;
- } else if self.channel_type.supports_scid_privacy() {
- self.channel_type.clear_scid_privacy();
+ if self.context.channel_type.supports_anchors_zero_fee_htlc_tx() {
+ self.context.channel_type.clear_anchors_zero_fee_htlc_tx();
+ assert!(self.context.channel_transaction_parameters.opt_non_zero_fee_anchors.is_none());
+ self.context.channel_transaction_parameters.opt_anchors = None;
+ } else if self.context.channel_type.supports_scid_privacy() {
+ self.context.channel_type.clear_scid_privacy();
} else {
- self.channel_type = ChannelTypeFeatures::only_static_remote_key();
+ self.context.channel_type = ChannelTypeFeatures::only_static_remote_key();
}
Ok(self.get_open_channel(chain_hash))
}
let temporary_channel_id = entropy_source.get_secure_random_bytes();
Ok(Channel {
- user_id,
+ context: ChannelContext {
+ user_id,
- config: LegacyChannelConfig {
- options: config.channel_config.clone(),
- announced_channel: config.channel_handshake_config.announced_channel,
- commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
- },
+ config: LegacyChannelConfig {
+ options: config.channel_config.clone(),
+ announced_channel: config.channel_handshake_config.announced_channel,
+ 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::OurInitSent as u32,
- announcement_sigs_state: AnnouncementSigsState::NotSent,
- secp_ctx,
- channel_value_satoshis,
-
- latest_monitor_update_id: 0,
-
- holder_signer,
- shutdown_scriptpubkey,
- destination_script,
-
- cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
- cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
- value_to_self_msat,
-
- 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_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(),
-
- #[cfg(debug_assertions)]
- holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
- #[cfg(debug_assertions)]
- counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
-
- last_sent_closing_fee: None,
- pending_counterparty_closing_signed: None,
- closing_fee_limits: None,
- target_closing_feerate_sats_per_kw: None,
-
- inbound_awaiting_accept: false,
-
- funding_tx_confirmed_in: None,
- funding_tx_confirmation_height: 0,
- short_channel_id: None,
- channel_creation_height: current_chain_height,
-
- feerate_per_kw: feerate,
- counterparty_dust_limit_satoshis: 0,
- holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
- counterparty_max_htlc_value_in_flight_msat: 0,
- holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &config.channel_handshake_config),
- counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
- holder_selected_channel_reserve_satoshis,
- 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),
- minimum_depth: None, // Filled in in accept_channel
-
- counterparty_forwarding_info: None,
-
- 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,
- opt_anchors: if channel_type.requires_anchors_zero_fee_htlc_tx() { Some(()) } else { None },
- opt_non_zero_fee_anchors: None
- },
- funding_transaction: None,
+ 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::OurInitSent as u32,
+ announcement_sigs_state: AnnouncementSigsState::NotSent,
+ secp_ctx,
+ channel_value_satoshis,
+
+ latest_monitor_update_id: 0,
+
+ holder_signer,
+ shutdown_scriptpubkey,
+ destination_script,
+
+ cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
+ cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
+ value_to_self_msat,
+
+ 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_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(),
+
+ #[cfg(debug_assertions)]
+ holder_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
+ #[cfg(debug_assertions)]
+ counterparty_max_commitment_tx_output: Mutex::new((channel_value_satoshis * 1000 - push_msat, push_msat)),
+
+ last_sent_closing_fee: None,
+ pending_counterparty_closing_signed: None,
+ closing_fee_limits: None,
+ target_closing_feerate_sats_per_kw: None,
+
+ inbound_awaiting_accept: false,
+
+ funding_tx_confirmed_in: None,
+ funding_tx_confirmation_height: 0,
+ short_channel_id: None,
+ channel_creation_height: current_chain_height,
+
+ feerate_per_kw: feerate,
+ counterparty_dust_limit_satoshis: 0,
+ holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
+ counterparty_max_htlc_value_in_flight_msat: 0,
+ holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(channel_value_satoshis, &config.channel_handshake_config),
+ counterparty_selected_channel_reserve_satoshis: None, // Filled in in accept_channel
+ holder_selected_channel_reserve_satoshis,
+ 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),
+ minimum_depth: None, // Filled in in accept_channel
+
+ counterparty_forwarding_info: None,
+
+ 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,
+ opt_anchors: if channel_type.requires_anchors_zero_fee_htlc_tx() { Some(()) } else { None },
+ opt_non_zero_fee_anchors: None
+ },
+ funding_transaction: None,
- counterparty_cur_commitment_point: None,
- counterparty_prev_commitment_point: None,
- counterparty_node_id,
+ counterparty_cur_commitment_point: None,
+ counterparty_prev_commitment_point: None,
+ counterparty_node_id,
- counterparty_shutdown_scriptpubkey: None,
+ counterparty_shutdown_scriptpubkey: None,
- commitment_secrets: CounterpartyCommitmentSecrets::new(),
+ commitment_secrets: CounterpartyCommitmentSecrets::new(),
- channel_update_status: ChannelUpdateStatus::Enabled,
- closing_signed_in_flight: false,
+ channel_update_status: ChannelUpdateStatus::Enabled,
+ closing_signed_in_flight: false,
- announcement_sigs: None,
+ announcement_sigs: None,
- #[cfg(any(test, fuzzing))]
- next_local_commitment_tx_fee_info_cached: Mutex::new(None),
- #[cfg(any(test, fuzzing))]
- next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
+ #[cfg(any(test, fuzzing))]
+ next_local_commitment_tx_fee_info_cached: Mutex::new(None),
+ #[cfg(any(test, fuzzing))]
+ next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
- workaround_lnd_bug_4006: None,
- sent_message_awaiting_response: None,
+ workaround_lnd_bug_4006: None,
+ sent_message_awaiting_response: None,
- latest_inbound_scid_alias: None,
- outbound_scid_alias,
+ latest_inbound_scid_alias: None,
+ outbound_scid_alias,
- channel_pending_event_emitted: false,
- channel_ready_event_emitted: false,
+ channel_pending_event_emitted: false,
+ channel_ready_event_emitted: false,
- #[cfg(any(test, fuzzing))]
- historical_inbound_htlc_fulfills: HashSet::new(),
+ #[cfg(any(test, fuzzing))]
+ historical_inbound_htlc_fulfills: HashSet::new(),
- channel_type,
- channel_keys_id,
+ channel_type,
+ channel_keys_id,
- pending_monitor_updates: Vec::new(),
+ pending_monitor_updates: Vec::new(),
+ }
})
}
secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
let chan = Channel {
- user_id,
+ context: ChannelContext {
+ user_id,
- config: LegacyChannelConfig {
- options: config.channel_config.clone(),
- announced_channel,
- commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
- },
+ config: LegacyChannelConfig {
+ options: config.channel_config.clone(),
+ announced_channel,
+ commit_upfront_shutdown_pubkey: config.channel_handshake_config.commit_upfront_shutdown_pubkey,
+ },
- prev_config: None,
-
- inbound_handshake_limits_override: None,
-
- channel_id: msg.temporary_channel_id,
- temporary_channel_id: Some(msg.temporary_channel_id),
- channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
- announcement_sigs_state: AnnouncementSigsState::NotSent,
- secp_ctx,
-
- latest_monitor_update_id: 0,
-
- holder_signer,
- shutdown_scriptpubkey,
- destination_script,
-
- cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
- cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
- value_to_self_msat: msg.push_msat,
-
- 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_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(),
-
- #[cfg(debug_assertions)]
- holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
- #[cfg(debug_assertions)]
- counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
-
- last_sent_closing_fee: None,
- pending_counterparty_closing_signed: None,
- closing_fee_limits: None,
- target_closing_feerate_sats_per_kw: None,
-
- inbound_awaiting_accept: true,
-
- funding_tx_confirmed_in: None,
- funding_tx_confirmation_height: 0,
- short_channel_id: None,
- channel_creation_height: current_chain_height,
-
- feerate_per_kw: msg.feerate_per_kw,
- channel_value_satoshis: msg.funding_satoshis,
- counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
- holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
- counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
- holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(msg.funding_satoshis, &config.channel_handshake_config),
- counterparty_selected_channel_reserve_satoshis: Some(msg.channel_reserve_satoshis),
- holder_selected_channel_reserve_satoshis,
- counterparty_htlc_minimum_msat: msg.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: msg.max_accepted_htlcs,
- holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
- minimum_depth: Some(cmp::max(config.channel_handshake_config.minimum_depth, 1)),
-
- counterparty_forwarding_info: None,
-
- 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: msg.to_self_delay,
- pubkeys: counterparty_pubkeys,
- }),
- funding_outpoint: None,
- opt_anchors: if opt_anchors { Some(()) } else { None },
- opt_non_zero_fee_anchors: None
- },
- funding_transaction: None,
+ prev_config: None,
+
+ inbound_handshake_limits_override: None,
+
+ temporary_channel_id: Some(msg.temporary_channel_id),
+ channel_id: msg.temporary_channel_id,
+ channel_state: (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32),
+ announcement_sigs_state: AnnouncementSigsState::NotSent,
+ secp_ctx,
+
+ latest_monitor_update_id: 0,
+
+ holder_signer,
+ shutdown_scriptpubkey,
+ destination_script,
+
+ cur_holder_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
+ cur_counterparty_commitment_transaction_number: INITIAL_COMMITMENT_NUMBER,
+ value_to_self_msat: msg.push_msat,
+
+ 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_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(),
+
+ #[cfg(debug_assertions)]
+ holder_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
+ #[cfg(debug_assertions)]
+ counterparty_max_commitment_tx_output: Mutex::new((msg.push_msat, msg.funding_satoshis * 1000 - msg.push_msat)),
+
+ last_sent_closing_fee: None,
+ pending_counterparty_closing_signed: None,
+ closing_fee_limits: None,
+ target_closing_feerate_sats_per_kw: None,
+
+ inbound_awaiting_accept: true,
+
+ funding_tx_confirmed_in: None,
+ funding_tx_confirmation_height: 0,
+ short_channel_id: None,
+ channel_creation_height: current_chain_height,
+
+ feerate_per_kw: msg.feerate_per_kw,
+ channel_value_satoshis: msg.funding_satoshis,
+ counterparty_dust_limit_satoshis: msg.dust_limit_satoshis,
+ holder_dust_limit_satoshis: MIN_CHAN_DUST_LIMIT_SATOSHIS,
+ counterparty_max_htlc_value_in_flight_msat: cmp::min(msg.max_htlc_value_in_flight_msat, msg.funding_satoshis * 1000),
+ holder_max_htlc_value_in_flight_msat: Self::get_holder_max_htlc_value_in_flight_msat(msg.funding_satoshis, &config.channel_handshake_config),
+ counterparty_selected_channel_reserve_satoshis: Some(msg.channel_reserve_satoshis),
+ holder_selected_channel_reserve_satoshis,
+ counterparty_htlc_minimum_msat: msg.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: msg.max_accepted_htlcs,
+ holder_max_accepted_htlcs: cmp::min(config.channel_handshake_config.our_max_accepted_htlcs, MAX_HTLCS),
+ minimum_depth: Some(cmp::max(config.channel_handshake_config.minimum_depth, 1)),
+
+ counterparty_forwarding_info: None,
+
+ 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: msg.to_self_delay,
+ pubkeys: counterparty_pubkeys,
+ }),
+ funding_outpoint: None,
+ opt_anchors: if opt_anchors { Some(()) } else { None },
+ opt_non_zero_fee_anchors: None
+ },
+ funding_transaction: None,
- counterparty_cur_commitment_point: Some(msg.first_per_commitment_point),
- counterparty_prev_commitment_point: None,
- counterparty_node_id,
+ counterparty_cur_commitment_point: Some(msg.first_per_commitment_point),
+ counterparty_prev_commitment_point: None,
+ counterparty_node_id,
- counterparty_shutdown_scriptpubkey,
+ counterparty_shutdown_scriptpubkey,
- commitment_secrets: CounterpartyCommitmentSecrets::new(),
+ commitment_secrets: CounterpartyCommitmentSecrets::new(),
- channel_update_status: ChannelUpdateStatus::Enabled,
- closing_signed_in_flight: false,
+ channel_update_status: ChannelUpdateStatus::Enabled,
+ closing_signed_in_flight: false,
- announcement_sigs: None,
+ announcement_sigs: None,
- #[cfg(any(test, fuzzing))]
- next_local_commitment_tx_fee_info_cached: Mutex::new(None),
- #[cfg(any(test, fuzzing))]
- next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
+ #[cfg(any(test, fuzzing))]
+ next_local_commitment_tx_fee_info_cached: Mutex::new(None),
+ #[cfg(any(test, fuzzing))]
+ next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
- workaround_lnd_bug_4006: None,
- sent_message_awaiting_response: None,
+ workaround_lnd_bug_4006: None,
+ sent_message_awaiting_response: None,
- latest_inbound_scid_alias: None,
- outbound_scid_alias,
+ latest_inbound_scid_alias: None,
+ outbound_scid_alias,
- channel_pending_event_emitted: false,
- channel_ready_event_emitted: false,
+ channel_pending_event_emitted: false,
+ channel_ready_event_emitted: false,
- #[cfg(any(test, fuzzing))]
- historical_inbound_htlc_fulfills: HashSet::new(),
+ #[cfg(any(test, fuzzing))]
+ historical_inbound_htlc_fulfills: HashSet::new(),
- channel_type,
- channel_keys_id,
+ channel_type,
+ channel_keys_id,
- pending_monitor_updates: Vec::new(),
+ pending_monitor_updates: Vec::new(),
+ }
};
Ok(chan)
where L::Target: Logger
{
let mut included_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::new();
- let num_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
+ let num_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
let mut included_non_dust_htlcs: Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)> = Vec::with_capacity(num_htlcs);
- let broadcaster_dust_limit_satoshis = if local { self.holder_dust_limit_satoshis } else { self.counterparty_dust_limit_satoshis };
+ let broadcaster_dust_limit_satoshis = if local { self.context.holder_dust_limit_satoshis } else { self.context.counterparty_dust_limit_satoshis };
let mut remote_htlc_total_msat = 0;
let mut local_htlc_total_msat = 0;
let mut value_to_self_msat_offset = 0;
- let mut feerate_per_kw = self.feerate_per_kw;
- if let Some((feerate, update_state)) = self.pending_update_fee {
+ let mut feerate_per_kw = self.context.feerate_per_kw;
+ if let Some((feerate, update_state)) = self.context.pending_update_fee {
if match update_state {
// Note that these match the inclusion criteria when scanning
// pending_inbound_htlcs below.
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(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()),
- log_bytes!(self.channel_id), if local { "us" } else { "remote" }, if generated_by_local { "us" } else { "remote" }, feerate_per_kw);
+ log_bytes!(self.context.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) => {
}
}
- for ref htlc in self.pending_inbound_htlcs.iter() {
+ for ref htlc in self.context.pending_inbound_htlcs.iter() {
let (include, state_name) = match htlc.state {
InboundHTLCState::RemoteAnnounced(_) => (!generated_by_local, "RemoteAnnounced"),
InboundHTLCState::AwaitingRemoteRevokeToAnnounce(_) => (!generated_by_local, "AwaitingRemoteRevokeToAnnounce"),
let mut preimages: Vec<PaymentPreimage> = Vec::new();
- for ref htlc in self.pending_outbound_htlcs.iter() {
+ for ref htlc in self.context.pending_outbound_htlcs.iter() {
let (include, state_name) = match htlc.state {
OutboundHTLCState::LocalAnnounced(_) => (generated_by_local, "LocalAnnounced"),
OutboundHTLCState::Committed => (true, "Committed"),
}
}
- let mut value_to_self_msat: i64 = (self.value_to_self_msat - local_htlc_total_msat) as i64 + value_to_self_msat_offset;
+ let mut value_to_self_msat: i64 = (self.context.value_to_self_msat - local_htlc_total_msat) as i64 + value_to_self_msat_offset;
assert!(value_to_self_msat >= 0);
// Note that in case they have several just-awaiting-last-RAA fulfills in-progress (ie
// AwaitingRemoteRevokeToRemove or AwaitingRemovedRemoteRevoke) we may have allowed them to
// "violate" their reserve value by couting those against it. Thus, we have to convert
// everything to i64 before subtracting as otherwise we can overflow.
- let mut value_to_remote_msat: i64 = (self.channel_value_satoshis * 1000) as i64 - (self.value_to_self_msat as i64) - (remote_htlc_total_msat as i64) - value_to_self_msat_offset;
+ let mut value_to_remote_msat: i64 = (self.context.channel_value_satoshis * 1000) as i64 - (self.context.value_to_self_msat as i64) - (remote_htlc_total_msat as i64) - value_to_self_msat_offset;
assert!(value_to_remote_msat >= 0);
#[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_max_commitment_tx_output = if generated_by_local {
- self.holder_max_commitment_tx_output.lock().unwrap()
+ self.context.holder_max_commitment_tx_output.lock().unwrap()
} else {
- self.counterparty_max_commitment_tx_output.lock().unwrap()
+ self.context.counterparty_max_commitment_tx_output.lock().unwrap()
};
- debug_assert!(broadcaster_max_commitment_tx_output.0 <= value_to_self_msat as u64 || value_to_self_msat / 1000 >= self.counterparty_selected_channel_reserve_satoshis.unwrap() as i64);
+ debug_assert!(broadcaster_max_commitment_tx_output.0 <= value_to_self_msat as u64 || value_to_self_msat / 1000 >= self.context.counterparty_selected_channel_reserve_satoshis.unwrap() as i64);
broadcaster_max_commitment_tx_output.0 = cmp::max(broadcaster_max_commitment_tx_output.0, value_to_self_msat as u64);
- debug_assert!(broadcaster_max_commitment_tx_output.1 <= value_to_remote_msat as u64 || value_to_remote_msat / 1000 >= self.holder_selected_channel_reserve_satoshis as i64);
+ debug_assert!(broadcaster_max_commitment_tx_output.1 <= value_to_remote_msat as u64 || value_to_remote_msat / 1000 >= self.context.holder_selected_channel_reserve_satoshis as i64);
broadcaster_max_commitment_tx_output.1 = cmp::max(broadcaster_max_commitment_tx_output.1, value_to_remote_msat as u64);
}
- let total_fee_sat = Channel::<Signer>::commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), self.channel_transaction_parameters.opt_anchors.is_some());
- let anchors_val = if self.channel_transaction_parameters.opt_anchors.is_some() { ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 } as i64;
+ let total_fee_sat = Channel::<Signer>::commit_tx_fee_sat(feerate_per_kw, included_non_dust_htlcs.len(), self.context.channel_transaction_parameters.opt_anchors.is_some());
+ let anchors_val = if self.context.channel_transaction_parameters.opt_anchors.is_some() { ANCHOR_OUTPUT_VALUE_SATOSHI * 2 } else { 0 } as i64;
let (value_to_self, value_to_remote) = if self.is_outbound() {
(value_to_self_msat / 1000 - anchors_val - total_fee_sat as i64, value_to_remote_msat / 1000)
} else {
let num_nondust_htlcs = included_non_dust_htlcs.len();
let channel_parameters =
- if local { self.channel_transaction_parameters.as_holder_broadcastable() }
- else { self.channel_transaction_parameters.as_counterparty_broadcastable() };
+ if local { self.context.channel_transaction_parameters.as_holder_broadcastable() }
+ else { self.context.channel_transaction_parameters.as_counterparty_broadcastable() };
let tx = CommitmentTransaction::new_with_auxiliary_htlc_data(commitment_number,
value_to_a as u64,
value_to_b as u64,
- self.channel_transaction_parameters.opt_anchors.is_some(),
+ self.context.channel_transaction_parameters.opt_anchors.is_some(),
funding_pubkey_a,
funding_pubkey_b,
keys.clone(),
// 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.shutdown_scriptpubkey.clone().unwrap().into_inner()
+ self.context.shutdown_scriptpubkey.clone().unwrap().into_inner()
}
#[inline]
#[inline]
fn build_closing_transaction(&self, proposed_total_fee_satoshis: u64, skip_remote_output: bool) -> (ClosingTransaction, u64) {
- assert!(self.pending_inbound_htlcs.is_empty());
- assert!(self.pending_outbound_htlcs.is_empty());
- assert!(self.pending_update_fee.is_none());
+ 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.value_to_self_msat as i64) / 1000 - if self.is_outbound() { total_fee_satoshis as i64 } else { 0 };
- let mut value_to_counterparty: i64 = ((self.channel_value_satoshis * 1000 - self.value_to_self_msat) as i64 / 1000) - if self.is_outbound() { 0 } else { total_fee_satoshis as i64 };
+ let mut value_to_holder: i64 = (self.context.value_to_self_msat as i64) / 1000 - if self.is_outbound() { total_fee_satoshis as i64 } else { 0 };
+ let mut value_to_counterparty: i64 = ((self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat) as i64 / 1000) - if self.is_outbound() { 0 } else { total_fee_satoshis as i64 };
if value_to_holder < 0 {
assert!(self.is_outbound());
total_fee_satoshis += (-value_to_counterparty) as u64;
}
- if skip_remote_output || value_to_counterparty as u64 <= self.holder_dust_limit_satoshis {
+ if skip_remote_output || value_to_counterparty as u64 <= self.context.holder_dust_limit_satoshis {
value_to_counterparty = 0;
}
- if value_to_holder as u64 <= self.holder_dust_limit_satoshis {
+ if value_to_holder as u64 <= self.context.holder_dust_limit_satoshis {
value_to_holder = 0;
}
- assert!(self.shutdown_scriptpubkey.is_some());
+ assert!(self.context.shutdown_scriptpubkey.is_some());
let holder_shutdown_script = self.get_closing_scriptpubkey();
- let counterparty_shutdown_script = self.counterparty_shutdown_scriptpubkey.clone().unwrap();
+ 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);
}
fn funding_outpoint(&self) -> OutPoint {
- self.channel_transaction_parameters.funding_outpoint.unwrap()
+ self.context.channel_transaction_parameters.funding_outpoint.unwrap()
}
#[inline]
/// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
/// TODO Some magic rust shit to compile-time check this?
fn build_holder_transaction_keys(&self, commitment_number: u64) -> TxCreationKeys {
- let per_commitment_point = self.holder_signer.get_per_commitment_point(commitment_number, &self.secp_ctx);
+ let per_commitment_point = self.context.holder_signer.get_per_commitment_point(commitment_number, &self.context.secp_ctx);
let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
let counterparty_pubkeys = self.get_counterparty_pubkeys();
- TxCreationKeys::derive_new(&self.secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint)
+ TxCreationKeys::derive_new(&self.context.secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint)
}
#[inline]
let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
let counterparty_pubkeys = self.get_counterparty_pubkeys();
- TxCreationKeys::derive_new(&self.secp_ctx, &self.counterparty_cur_commitment_point.unwrap(), &counterparty_pubkeys.delayed_payment_basepoint, &counterparty_pubkeys.htlc_basepoint, revocation_basepoint, htlc_basepoint)
+ TxCreationKeys::derive_new(&self.context.secp_ctx, &self.context.counterparty_cur_commitment_point.unwrap(), &counterparty_pubkeys.delayed_payment_basepoint, &counterparty_pubkeys.htlc_basepoint, revocation_basepoint, htlc_basepoint)
}
/// Gets the redeemscript for the funding transaction output (ie the funding transaction output
where L::Target: Logger {
// Assert that we'll add the HTLC claim to the holding cell in `get_update_fulfill_htlc`
// (see equivalent if condition there).
- assert!(self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0);
- let mon_update_id = self.latest_monitor_update_id; // Forget the ChannelMonitor update
+ assert!(self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0);
+ 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, logger);
- self.latest_monitor_update_id = mon_update_id;
+ self.context.latest_monitor_update_id = mon_update_id;
if let UpdateFulfillFetch::NewClaim { msg, .. } = fulfill_resp {
assert!(msg.is_none()); // The HTLC must have ended up in the holding cell.
}
// 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 (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
panic!("Was asked to fulfill an HTLC when channel was not in an operational state");
}
- assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
+ assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
let payment_hash_calc = PaymentHash(Sha256::hash(&payment_preimage_arg.0[..]).into_inner());
let mut pending_idx = core::usize::MAX;
let mut htlc_value_msat = 0;
- for (idx, htlc) in self.pending_inbound_htlcs.iter().enumerate() {
+ for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
if htlc.htlc_id == htlc_id_arg {
assert_eq!(htlc.payment_hash, payment_hash_calc);
match htlc.state {
#[cfg(any(test, fuzzing))]
// If we failed to find an HTLC to fulfill, make sure it was previously fulfilled and
// this is simply a duplicate claim, not previously failed and we lost funds.
- debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
+ debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
return UpdateFulfillFetch::DuplicateClaim {};
}
//
// 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.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::PaymentPreimage {
payment_preimage: payment_preimage_arg.clone(),
}],
};
- if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
+ if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
// 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.holding_cell_htlc_updates.iter() {
+ 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.latest_monitor_update_id -= 1;
+ self.context.latest_monitor_update_id -= 1;
#[cfg(any(test, fuzzing))]
- debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
+ debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
return UpdateFulfillFetch::DuplicateClaim {};
}
},
_ => {}
}
}
- log_trace!(logger, "Adding HTLC claim to holding_cell in channel {}! Current state: {}", log_bytes!(self.channel_id()), self.channel_state);
- self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
+ log_trace!(logger, "Adding HTLC claim to holding_cell in channel {}! Current state: {}", log_bytes!(self.channel_id()), self.context.channel_state);
+ self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::ClaimHTLC {
payment_preimage: payment_preimage_arg, htlc_id: htlc_id_arg,
});
#[cfg(any(test, fuzzing))]
- self.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
+ self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
return UpdateFulfillFetch::NewClaim { monitor_update, htlc_value_msat, msg: None };
}
#[cfg(any(test, fuzzing))]
- self.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
+ self.context.historical_inbound_htlc_fulfills.insert(htlc_id_arg);
{
- let htlc = &mut self.pending_inbound_htlcs[pending_idx];
+ 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, msg: None };
}
- log_trace!(logger, "Upgrading HTLC {} to LocalRemoved with a Fulfill in channel {}!", log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
+ log_trace!(logger, "Upgrading HTLC {} to LocalRemoved with a Fulfill in channel {}!", log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(payment_preimage_arg.clone()));
}
}
pub fn get_update_fulfill_htlc_and_commit<L: Deref>(&mut self, htlc_id: u64, payment_preimage: PaymentPreimage, logger: &L) -> UpdateFulfillCommitFetch where L::Target: Logger {
- let release_cs_monitor = self.pending_monitor_updates.iter().all(|upd| !upd.blocked);
+ let release_cs_monitor = self.context.pending_monitor_updates.iter().all(|upd| !upd.blocked);
match self.get_update_fulfill_htlc(htlc_id, payment_preimage, logger) {
UpdateFulfillFetch::NewClaim { mut monitor_update, htlc_value_msat, msg } => {
// Even if we aren't supposed to let new monitor updates with commitment state
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.latest_monitor_update_id = monitor_update.update_id;
+ self.context.latest_monitor_update_id = monitor_update.update_id;
monitor_update.updates.append(&mut additional_update.updates);
- self.pending_monitor_updates.push(PendingChannelMonitorUpdate {
+ self.context.pending_monitor_updates.push(PendingChannelMonitorUpdate {
update: monitor_update, blocked: false,
});
- self.pending_monitor_updates.len() - 1
+ self.context.pending_monitor_updates.len() - 1
} else {
- let insert_pos = self.pending_monitor_updates.iter().position(|upd| upd.blocked)
- .unwrap_or(self.pending_monitor_updates.len());
- let new_mon_id = self.pending_monitor_updates.get(insert_pos)
+ let insert_pos = self.context.pending_monitor_updates.iter().position(|upd| upd.blocked)
+ .unwrap_or(self.context.pending_monitor_updates.len());
+ let new_mon_id = self.context.pending_monitor_updates.get(insert_pos)
.map(|upd| upd.update.update_id).unwrap_or(monitor_update.update_id);
monitor_update.update_id = new_mon_id;
- self.pending_monitor_updates.insert(insert_pos, PendingChannelMonitorUpdate {
+ self.context.pending_monitor_updates.insert(insert_pos, PendingChannelMonitorUpdate {
update: monitor_update, blocked: false,
});
- for held_update in self.pending_monitor_updates.iter_mut().skip(insert_pos + 1) {
+ for held_update in self.context.pending_monitor_updates.iter_mut().skip(insert_pos + 1) {
held_update.update.update_id += 1;
}
if msg.is_some() {
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.pending_monitor_updates.push(PendingChannelMonitorUpdate {
+ self.context.pending_monitor_updates.push(PendingChannelMonitorUpdate {
update, blocked: true,
});
}
};
self.monitor_updating_paused(false, msg.is_some(), false, Vec::new(), Vec::new(), Vec::new());
UpdateFulfillCommitFetch::NewClaim {
- monitor_update: &self.pending_monitor_updates.get(unblocked_update_pos)
+ monitor_update: &self.context.pending_monitor_updates.get(unblocked_update_pos)
.expect("We just pushed the monitor update").update,
htlc_value_msat,
}
/// [`ChannelError::Ignore`].
fn fail_htlc<L: Deref>(&mut self, htlc_id_arg: u64, err_packet: msgs::OnionErrorPacket, mut force_holding_cell: bool, logger: &L)
-> Result<Option<msgs::UpdateFailHTLC>, ChannelError> where L::Target: Logger {
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
panic!("Was asked to fail an HTLC when channel was not in an operational state");
}
- assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
+ assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
// 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.pending_inbound_htlcs.iter().enumerate() {
+ for (idx, htlc) in self.context.pending_inbound_htlcs.iter().enumerate() {
if htlc.htlc_id == htlc_id_arg {
match htlc.state {
InboundHTLCState::Committed => {},
#[cfg(any(test, fuzzing))]
// If we failed to find an HTLC to fail, make sure it was previously fulfilled and this
// is simply a duplicate fail, not previously failed and we failed-back too early.
- debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
+ debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
return Ok(None);
}
- if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
+ if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
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.holding_cell_htlc_updates.iter() {
+ for pending_update in self.context.holding_cell_htlc_updates.iter() {
match pending_update {
&HTLCUpdateAwaitingACK::ClaimHTLC { htlc_id, .. } => {
if htlc_id_arg == htlc_id {
#[cfg(any(test, fuzzing))]
- debug_assert!(self.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
+ debug_assert!(self.context.historical_inbound_htlc_fulfills.contains(&htlc_id_arg));
return Ok(None);
}
},
}
}
log_trace!(logger, "Placing failure for HTLC ID {} in holding cell in channel {}.", htlc_id_arg, log_bytes!(self.channel_id()));
- self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::FailHTLC {
+ self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::FailHTLC {
htlc_id: htlc_id_arg,
err_packet,
});
log_trace!(logger, "Failing HTLC ID {} back with a update_fail_htlc message in channel {}.", htlc_id_arg, log_bytes!(self.channel_id()));
{
- let htlc = &mut self.pending_inbound_htlcs[pending_idx];
+ let htlc = &mut self.context.pending_inbound_htlcs[pending_idx];
htlc.state = InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::FailRelay(err_packet.clone()));
}
// Message handlers:
pub fn accept_channel(&mut self, msg: &msgs::AcceptChannel, default_limits: &ChannelHandshakeLimits, their_features: &InitFeatures) -> Result<(), ChannelError> {
- let peer_limits = if let Some(ref limits) = self.inbound_handshake_limits_override { limits } else { default_limits };
+ let peer_limits = if let Some(ref limits) = self.context.inbound_handshake_limits_override { limits } else { default_limits };
// Check sanity of message fields:
if !self.is_outbound() {
return Err(ChannelError::Close("Got an accept_channel message from an inbound peer".to_owned()));
}
- if self.channel_state != ChannelState::OurInitSent as u32 {
+ if self.context.channel_state != ChannelState::OurInitSent as u32 {
return Err(ChannelError::Close("Got an accept_channel message at a strange time".to_owned()));
}
if msg.dust_limit_satoshis > 21000000 * 100000000 {
return Err(ChannelError::Close(format!("Peer never wants payout outputs? dust_limit_satoshis was {}", msg.dust_limit_satoshis)));
}
- if msg.channel_reserve_satoshis > self.channel_value_satoshis {
- return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.channel_value_satoshis)));
+ if msg.channel_reserve_satoshis > self.context.channel_value_satoshis {
+ return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.context.channel_value_satoshis)));
}
- if msg.dust_limit_satoshis > self.holder_selected_channel_reserve_satoshis {
- return Err(ChannelError::Close(format!("Dust limit ({}) is bigger than our channel reserve ({})", msg.dust_limit_satoshis, self.holder_selected_channel_reserve_satoshis)));
+ if msg.dust_limit_satoshis > self.context.holder_selected_channel_reserve_satoshis {
+ return Err(ChannelError::Close(format!("Dust limit ({}) is bigger than our channel reserve ({})", msg.dust_limit_satoshis, self.context.holder_selected_channel_reserve_satoshis)));
}
- if msg.channel_reserve_satoshis > self.channel_value_satoshis - self.holder_selected_channel_reserve_satoshis {
+ if msg.channel_reserve_satoshis > self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis {
return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than channel value minus our reserve ({})",
- msg.channel_reserve_satoshis, self.channel_value_satoshis - self.holder_selected_channel_reserve_satoshis)));
+ msg.channel_reserve_satoshis, self.context.channel_value_satoshis - self.context.holder_selected_channel_reserve_satoshis)));
}
- let full_channel_value_msat = (self.channel_value_satoshis - msg.channel_reserve_satoshis) * 1000;
+ let full_channel_value_msat = (self.context.channel_value_satoshis - msg.channel_reserve_satoshis) * 1000;
if msg.htlc_minimum_msat >= full_channel_value_msat {
return Err(ChannelError::Close(format!("Minimum htlc value ({}) is full channel value ({})", msg.htlc_minimum_msat, full_channel_value_msat)));
}
}
if let Some(ty) = &msg.channel_type {
- if *ty != self.channel_type {
+ if *ty != self.context.channel_type {
return Err(ChannelError::Close("Channel Type in accept_channel didn't match the one sent in open_channel.".to_owned()));
}
} else if their_features.supports_channel_type() {
if channel_type != ChannelTypeFeatures::only_static_remote_key() {
return Err(ChannelError::Close("Only static_remote_key is supported for non-negotiated channel types".to_owned()));
}
- self.channel_type = channel_type;
+ self.context.channel_type = channel_type;
}
let counterparty_shutdown_scriptpubkey = if their_features.supports_upfront_shutdown_script() {
}
} else { None };
- self.counterparty_dust_limit_satoshis = msg.dust_limit_satoshis;
- self.counterparty_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.channel_value_satoshis * 1000);
- self.counterparty_selected_channel_reserve_satoshis = Some(msg.channel_reserve_satoshis);
- self.counterparty_htlc_minimum_msat = msg.htlc_minimum_msat;
- self.counterparty_max_accepted_htlcs = msg.max_accepted_htlcs;
+ self.context.counterparty_dust_limit_satoshis = msg.dust_limit_satoshis;
+ self.context.counterparty_max_htlc_value_in_flight_msat = cmp::min(msg.max_htlc_value_in_flight_msat, self.context.channel_value_satoshis * 1000);
+ self.context.counterparty_selected_channel_reserve_satoshis = Some(msg.channel_reserve_satoshis);
+ self.context.counterparty_htlc_minimum_msat = msg.htlc_minimum_msat;
+ self.context.counterparty_max_accepted_htlcs = msg.max_accepted_htlcs;
if peer_limits.trust_own_funding_0conf {
- self.minimum_depth = Some(msg.minimum_depth);
+ self.context.minimum_depth = Some(msg.minimum_depth);
} else {
- self.minimum_depth = Some(cmp::max(1, msg.minimum_depth));
+ self.context.minimum_depth = Some(cmp::max(1, msg.minimum_depth));
}
let counterparty_pubkeys = ChannelPublicKeys {
htlc_basepoint: msg.htlc_basepoint
};
- self.channel_transaction_parameters.counterparty_parameters = Some(CounterpartyChannelTransactionParameters {
+ self.context.channel_transaction_parameters.counterparty_parameters = Some(CounterpartyChannelTransactionParameters {
selected_contest_delay: msg.to_self_delay,
pubkeys: counterparty_pubkeys,
});
- self.counterparty_cur_commitment_point = Some(msg.first_per_commitment_point);
- self.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;
+ self.context.counterparty_cur_commitment_point = Some(msg.first_per_commitment_point);
+ self.context.counterparty_shutdown_scriptpubkey = counterparty_shutdown_scriptpubkey;
- self.channel_state = ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32;
- self.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.
+ self.context.channel_state = ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32;
+ self.context.inbound_handshake_limits_override = None; // We're done enforcing limits on our peer's handshake now.
Ok(())
}
fn funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<(Txid, CommitmentTransaction, Signature), ChannelError> where L::Target: Logger {
let funding_script = self.get_funding_redeemscript();
- let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
- let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, logger).tx;
+ let keys = self.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
+ let initial_commitment_tx = self.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger).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.channel_value_satoshis);
+ let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
// They sign the holder commitment transaction...
log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} for channel {}.",
log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.counterparty_funding_pubkey().serialize()),
encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]),
encode::serialize_hex(&funding_script), log_bytes!(self.channel_id()));
- secp_check!(self.secp_ctx.verify_ecdsa(&sighash, &sig, self.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
+ secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &sig, self.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
}
let counterparty_keys = self.build_remote_transaction_keys();
- let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
+ let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).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 {}",
log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
- let counterparty_signature = self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
+ let counterparty_signature = self.context.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
if self.is_outbound() {
return Err(ChannelError::Close("Received funding_created for an outbound channel?".to_owned()));
}
- if self.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
+ if self.context.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
// 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.
return Err(ChannelError::Close("Received funding_created after we got the channel!".to_owned()));
}
- if self.inbound_awaiting_accept {
+ if self.context.inbound_awaiting_accept {
return Err(ChannelError::Close("FundingCreated message received before the channel was accepted".to_owned()));
}
- if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
- self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
- self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
+ if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
+ self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
+ self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
}
let funding_txo = OutPoint { txid: msg.funding_txid, index: msg.funding_output_index };
- self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
+ self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
// This is an externally observable change before we finish all our checks. In particular
// funding_created_signature may fail.
- self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
+ self.context.holder_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
let (counterparty_initial_commitment_txid, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
Ok(res) => res,
Err(ChannelError::Close(e)) => {
- self.channel_transaction_parameters.funding_outpoint = None;
+ self.context.channel_transaction_parameters.funding_outpoint = None;
return Err(ChannelError::Close(e));
},
Err(e) => {
self.counterparty_funding_pubkey()
);
- self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
+ self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
// Now that we're past error-generating stuff, update our local state:
let funding_redeemscript = self.get_funding_redeemscript();
let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound());
- let shutdown_script = self.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
- let mut monitor_signer = signer_provider.derive_channel_signer(self.channel_value_satoshis, self.channel_keys_id);
- monitor_signer.provide_channel_parameters(&self.channel_transaction_parameters);
- let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), monitor_signer,
+ let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
+ let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
+ monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
+ let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
shutdown_script, self.get_holder_selected_contest_delay(),
- &self.destination_script, (funding_txo, funding_txo_script.clone()),
- &self.channel_transaction_parameters,
- funding_redeemscript.clone(), self.channel_value_satoshis,
+ &self.context.destination_script, (funding_txo, funding_txo_script.clone()),
+ &self.context.channel_transaction_parameters,
+ funding_redeemscript.clone(), self.context.channel_value_satoshis,
obscure_factor,
- holder_commitment_tx, best_block, self.counterparty_node_id);
+ holder_commitment_tx, best_block, self.context.counterparty_node_id);
- channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_commitment_txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
+ channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_commitment_txid, Vec::new(), self.context.cur_counterparty_commitment_transaction_number, self.context.counterparty_cur_commitment_point.unwrap(), logger);
- self.channel_state = ChannelState::FundingSent as u32;
- self.channel_id = funding_txo.to_channel_id();
- self.cur_counterparty_commitment_transaction_number -= 1;
- self.cur_holder_commitment_transaction_number -= 1;
+ self.context.channel_state = ChannelState::FundingSent as u32;
+ self.context.channel_id = funding_txo.to_channel_id();
+ self.context.cur_counterparty_commitment_transaction_number -= 1;
+ self.context.cur_holder_commitment_transaction_number -= 1;
log_info!(logger, "Generated funding_signed for peer for channel {}", log_bytes!(self.channel_id()));
self.monitor_updating_paused(false, false, need_channel_ready, Vec::new(), Vec::new(), Vec::new());
Ok((msgs::FundingSigned {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
signature,
#[cfg(taproot)]
partial_signature_with_nonce: None,
if !self.is_outbound() {
return Err(ChannelError::Close("Received funding_signed for an inbound channel?".to_owned()));
}
- if self.channel_state & !(ChannelState::MonitorUpdateInProgress as u32) != ChannelState::FundingCreated as u32 {
+ if self.context.channel_state & !(ChannelState::MonitorUpdateInProgress as u32) != ChannelState::FundingCreated as u32 {
return Err(ChannelError::Close("Received funding_signed in strange state!".to_owned()));
}
- if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
- self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
- self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
+ if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
+ self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
+ self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
}
let funding_script = self.get_funding_redeemscript();
let counterparty_keys = self.build_remote_transaction_keys();
- let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
+ let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).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 {}",
log_bytes!(self.channel_id()), counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
- let holder_signer = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
- let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &holder_signer, true, false, logger).tx;
+ let holder_signer = self.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
+ let initial_commitment_tx = self.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &holder_signer, true, false, logger).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.channel_value_satoshis);
+ let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_value_satoshis);
// They sign our commitment transaction, allowing us to broadcast the tx if we wish.
- if let Err(_) = self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
+ if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
return Err(ChannelError::Close("Invalid funding_signed signature from peer".to_owned()));
}
}
self.counterparty_funding_pubkey()
);
- self.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
+ self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, Vec::new())
.map_err(|_| ChannelError::Close("Failed to validate our commitment".to_owned()))?;
let funding_txo = self.get_funding_txo().unwrap();
let funding_txo_script = funding_redeemscript.to_v0_p2wsh();
let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound());
- let shutdown_script = self.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
- let mut monitor_signer = signer_provider.derive_channel_signer(self.channel_value_satoshis, self.channel_keys_id);
- monitor_signer.provide_channel_parameters(&self.channel_transaction_parameters);
- let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), monitor_signer,
+ let shutdown_script = self.context.shutdown_scriptpubkey.clone().map(|script| script.into_inner());
+ let mut monitor_signer = signer_provider.derive_channel_signer(self.context.channel_value_satoshis, self.context.channel_keys_id);
+ monitor_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
+ let channel_monitor = ChannelMonitor::new(self.context.secp_ctx.clone(), monitor_signer,
shutdown_script, self.get_holder_selected_contest_delay(),
- &self.destination_script, (funding_txo, funding_txo_script),
- &self.channel_transaction_parameters,
- funding_redeemscript.clone(), self.channel_value_satoshis,
+ &self.context.destination_script, (funding_txo, funding_txo_script),
+ &self.context.channel_transaction_parameters,
+ funding_redeemscript.clone(), self.context.channel_value_satoshis,
obscure_factor,
- holder_commitment_tx, best_block, self.counterparty_node_id);
+ holder_commitment_tx, best_block, self.context.counterparty_node_id);
- channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_bitcoin_tx.txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
+ channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_bitcoin_tx.txid, Vec::new(), self.context.cur_counterparty_commitment_transaction_number, self.context.counterparty_cur_commitment_point.unwrap(), logger);
- assert_eq!(self.channel_state & (ChannelState::MonitorUpdateInProgress as u32), 0); // We have no had any monitor(s) yet to fail update!
- self.channel_state = ChannelState::FundingSent as u32;
- self.cur_holder_commitment_transaction_number -= 1;
- self.cur_counterparty_commitment_transaction_number -= 1;
+ assert_eq!(self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32), 0); // We have no had any monitor(s) yet to fail update!
+ self.context.channel_state = ChannelState::FundingSent as u32;
+ self.context.cur_holder_commitment_transaction_number -= 1;
+ self.context.cur_counterparty_commitment_transaction_number -= 1;
log_info!(logger, "Received funding_signed from peer for channel {}", log_bytes!(self.channel_id()));
NS::Target: NodeSigner,
L::Target: Logger
{
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
- self.workaround_lnd_bug_4006 = Some(msg.clone());
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ 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.short_channel_id {
+ if Some(scid_alias) != self.context.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.latest_inbound_scid_alias = Some(scid_alias);
+ self.context.latest_inbound_scid_alias = Some(scid_alias);
}
}
- let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
+ let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
if non_shutdown_state == ChannelState::FundingSent as u32 {
- self.channel_state |= ChannelState::TheirChannelReady as u32;
+ self.context.channel_state |= ChannelState::TheirChannelReady as u32;
} else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
- self.channel_state = ChannelState::ChannelReady as u32 | (self.channel_state & MULTI_STATE_FLAGS);
- self.update_time_counter += 1;
- } else if self.channel_state & (ChannelState::ChannelReady as u32) != 0 ||
+ self.context.channel_state = ChannelState::ChannelReady as u32 | (self.context.channel_state & MULTI_STATE_FLAGS);
+ self.context.update_time_counter += 1;
+ } else if self.context.channel_state & (ChannelState::ChannelReady as u32) != 0 ||
// If we reconnected before sending our `channel_ready` they may still resend theirs:
- (self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) ==
+ (self.context.channel_state & (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) ==
(ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32))
{
// 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.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
+ if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
// If they haven't ever sent an updated point, the point they send should match
// the current one.
- self.counterparty_cur_commitment_point
- } else if self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
+ self.context.counterparty_cur_commitment_point
+ } else if self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 2 {
// If we've advanced the commitment number once, the second commitment point is
// at `counterparty_prev_commitment_point`, which is not yet revoked.
- debug_assert!(self.counterparty_prev_commitment_point.is_some());
- self.counterparty_prev_commitment_point
+ debug_assert!(self.context.counterparty_prev_commitment_point.is_some());
+ self.context.counterparty_prev_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.secp_ctx, &SecretKey::from_slice(
- &self.commitment_secrets.get_secret(INITIAL_COMMITMENT_NUMBER - 1).expect("We should have all prev secrets available")
+ 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 channel_ready at a strange time".to_owned()));
}
- self.counterparty_prev_commitment_point = self.counterparty_cur_commitment_point;
- self.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
+ self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
+ self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
log_info!(logger, "Received channel_ready from peer for channel {}", log_bytes!(self.channel_id()));
/// Returns transaction if there is pending funding transaction that is yet to broadcast
pub fn unbroadcasted_funding(&self) -> Option<Transaction> {
- if self.channel_state & (ChannelState::FundingCreated as u32) != 0 {
- self.funding_transaction.clone()
+ if self.context.channel_state & (ChannelState::FundingCreated as u32) != 0 {
+ self.context.funding_transaction.clone()
} else {
None
}
/// Returns a HTLCStats about inbound pending htlcs
fn get_inbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
let mut stats = HTLCStats {
- pending_htlcs: self.pending_inbound_htlcs.len() as u32,
+ pending_htlcs: self.context.pending_inbound_htlcs.len() as u32,
pending_htlcs_value_msat: 0,
on_counterparty_tx_dust_exposure_msat: 0,
on_holder_tx_dust_exposure_msat: 0,
(dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
};
- let counterparty_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
- let holder_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
- for ref htlc in self.pending_inbound_htlcs.iter() {
+ let counterparty_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.context.counterparty_dust_limit_satoshis;
+ let holder_dust_limit_success_sat = htlc_success_dust_limit + self.context.holder_dust_limit_satoshis;
+ for ref htlc in self.context.pending_inbound_htlcs.iter() {
stats.pending_htlcs_value_msat += htlc.amount_msat;
if htlc.amount_msat / 1000 < counterparty_dust_limit_timeout_sat {
stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
/// Returns a HTLCStats about pending outbound htlcs, *including* pending adds in our holding cell.
fn get_outbound_pending_htlc_stats(&self, outbound_feerate_update: Option<u32>) -> HTLCStats {
let mut stats = HTLCStats {
- pending_htlcs: self.pending_outbound_htlcs.len() as u32,
+ pending_htlcs: self.context.pending_outbound_htlcs.len() as u32,
pending_htlcs_value_msat: 0,
on_counterparty_tx_dust_exposure_msat: 0,
on_holder_tx_dust_exposure_msat: 0,
(dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
};
- let counterparty_dust_limit_success_sat = htlc_success_dust_limit + self.counterparty_dust_limit_satoshis;
- let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
- for ref htlc in self.pending_outbound_htlcs.iter() {
+ let counterparty_dust_limit_success_sat = htlc_success_dust_limit + self.context.counterparty_dust_limit_satoshis;
+ let holder_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.context.holder_dust_limit_satoshis;
+ for ref htlc in self.context.pending_outbound_htlcs.iter() {
stats.pending_htlcs_value_msat += htlc.amount_msat;
if htlc.amount_msat / 1000 < counterparty_dust_limit_success_sat {
stats.on_counterparty_tx_dust_exposure_msat += htlc.amount_msat;
}
}
- for update in self.holding_cell_htlc_updates.iter() {
+ for update in self.context.holding_cell_htlc_updates.iter() {
if let &HTLCUpdateAwaitingACK::AddHTLC { ref amount_msat, .. } = update {
stats.pending_htlcs += 1;
stats.pending_htlcs_value_msat += amount_msat;
let inbound_stats = self.get_inbound_pending_htlc_stats(None);
let outbound_stats = self.get_outbound_pending_htlc_stats(None);
- let mut balance_msat = self.value_to_self_msat;
- for ref htlc in self.pending_inbound_htlcs.iter() {
+ let mut balance_msat = self.context.value_to_self_msat;
+ for ref htlc in self.context.pending_inbound_htlcs.iter() {
if let InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_)) = htlc.state {
balance_msat += htlc.amount_msat;
}
}
balance_msat -= outbound_stats.pending_htlcs_value_msat;
- let outbound_capacity_msat = self.value_to_self_msat
+ let outbound_capacity_msat = self.context.value_to_self_msat
.saturating_sub(outbound_stats.pending_htlcs_value_msat)
.saturating_sub(
- self.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000);
+ self.context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0) * 1000);
let mut available_capacity_msat = outbound_capacity_msat;
// and the answer will in turn change the amount itself — making it a circular
// dependency.
// This complicates the computation around dust-values, up to the one-htlc-value.
- let mut real_dust_limit_timeout_sat = self.holder_dust_limit_satoshis;
+ let mut real_dust_limit_timeout_sat = self.context.holder_dust_limit_satoshis;
if !self.opt_anchors() {
- real_dust_limit_timeout_sat += self.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000;
+ real_dust_limit_timeout_sat += self.context.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000;
}
let htlc_above_dust = HTLCCandidate::new(real_dust_limit_timeout_sat * 1000, HTLCInitiator::LocalOffered);
} else {
// If the channel is inbound (i.e. counterparty pays the fee), we need to make sure
// sending a new HTLC won't reduce their balance below our reserve threshold.
- let mut real_dust_limit_success_sat = self.counterparty_dust_limit_satoshis;
+ let mut real_dust_limit_success_sat = self.context.counterparty_dust_limit_satoshis;
if !self.opt_anchors() {
- real_dust_limit_success_sat += self.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000;
+ real_dust_limit_success_sat += self.context.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000;
}
let htlc_above_dust = HTLCCandidate::new(real_dust_limit_success_sat * 1000, HTLCInitiator::LocalOffered);
let max_reserved_commit_tx_fee_msat = self.next_remote_commit_tx_fee_msat(htlc_above_dust, None);
- let holder_selected_chan_reserve_msat = self.holder_selected_channel_reserve_satoshis * 1000;
- let remote_balance_msat = (self.channel_value_satoshis * 1000 - self.value_to_self_msat)
+ let holder_selected_chan_reserve_msat = self.context.holder_selected_channel_reserve_satoshis * 1000;
+ let remote_balance_msat = (self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat)
.saturating_sub(inbound_stats.pending_htlcs_value_msat);
if remote_balance_msat < max_reserved_commit_tx_fee_msat + holder_selected_chan_reserve_msat {
}
}
- let mut next_outbound_htlc_minimum_msat = self.counterparty_htlc_minimum_msat;
+ let mut next_outbound_htlc_minimum_msat = self.context.counterparty_htlc_minimum_msat;
// If we get close to our maximum dust exposure, we end up in a situation where we can send
// between zero and the remaining dust exposure limit remaining OR above the dust limit.
let mut dust_exposure_dust_limit_msat = 0;
let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
- (self.counterparty_dust_limit_satoshis, self.holder_dust_limit_satoshis)
+ (self.context.counterparty_dust_limit_satoshis, self.context.holder_dust_limit_satoshis)
} else {
let dust_buffer_feerate = self.get_dust_buffer_feerate(None) as u64;
- (self.counterparty_dust_limit_satoshis + dust_buffer_feerate * htlc_success_tx_weight(false) / 1000,
- self.holder_dust_limit_satoshis + dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000)
+ (self.context.counterparty_dust_limit_satoshis + dust_buffer_feerate * htlc_success_tx_weight(false) / 1000,
+ self.context.holder_dust_limit_satoshis + dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000)
};
let on_counterparty_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat;
if on_counterparty_dust_htlc_exposure_msat as i64 + htlc_success_dust_limit as i64 * 1000 - 1 > self.get_max_dust_htlc_exposure_msat() as i64 {
}
available_capacity_msat = cmp::min(available_capacity_msat,
- self.counterparty_max_htlc_value_in_flight_msat - outbound_stats.pending_htlcs_value_msat);
+ self.context.counterparty_max_htlc_value_in_flight_msat - outbound_stats.pending_htlcs_value_msat);
- if outbound_stats.pending_htlcs + 1 > self.counterparty_max_accepted_htlcs as u32 {
+ if outbound_stats.pending_htlcs + 1 > self.context.counterparty_max_accepted_htlcs as u32 {
available_capacity_msat = 0;
}
AvailableBalances {
- inbound_capacity_msat: cmp::max(self.channel_value_satoshis as i64 * 1000
- - self.value_to_self_msat as i64
+ inbound_capacity_msat: cmp::max(self.context.channel_value_satoshis as i64 * 1000
+ - self.context.value_to_self_msat as i64
- self.get_inbound_pending_htlc_stats(None).pending_htlcs_value_msat as i64
- - self.holder_selected_channel_reserve_satoshis as i64 * 1000,
+ - self.context.holder_selected_channel_reserve_satoshis as i64 * 1000,
0) as u64,
outbound_capacity_msat,
next_outbound_htlc_limit_msat: available_capacity_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)
+ (self.context.holder_selected_channel_reserve_satoshis, self.context.counterparty_selected_channel_reserve_satoshis)
}
// Get the fee cost in MSATS of a commitment tx with a given number of HTLC outputs.
let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
(0, 0)
} else {
- (self.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
- self.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
+ (self.context.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
+ self.context.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
};
- let real_dust_limit_success_sat = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
- let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.holder_dust_limit_satoshis;
+ let real_dust_limit_success_sat = htlc_success_dust_limit + self.context.holder_dust_limit_satoshis;
+ let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.context.holder_dust_limit_satoshis;
let mut addl_htlcs = 0;
if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
}
let mut included_htlcs = 0;
- for ref htlc in self.pending_inbound_htlcs.iter() {
+ for ref htlc in self.context.pending_inbound_htlcs.iter() {
if htlc.amount_msat / 1000 < real_dust_limit_success_sat {
continue
}
included_htlcs += 1;
}
- for ref htlc in self.pending_outbound_htlcs.iter() {
+ for ref htlc in self.context.pending_outbound_htlcs.iter() {
if htlc.amount_msat / 1000 < real_dust_limit_timeout_sat {
continue
}
}
}
- for htlc in self.holding_cell_htlc_updates.iter() {
+ for htlc in self.context.holding_cell_htlc_updates.iter() {
match htlc {
&HTLCUpdateAwaitingACK::AddHTLC { amount_msat, .. } => {
if amount_msat / 1000 < real_dust_limit_timeout_sat {
}
let num_htlcs = included_htlcs + addl_htlcs;
- let res = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs, self.opt_anchors());
+ let res = Self::commit_tx_fee_msat(self.context.feerate_per_kw, num_htlcs, self.opt_anchors());
#[cfg(any(test, fuzzing))]
{
let mut fee = res;
if fee_spike_buffer_htlc.is_some() {
- fee = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
+ fee = Self::commit_tx_fee_msat(self.context.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
}
- let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len()
- + self.holding_cell_htlc_updates.len();
+ let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len()
+ + self.context.holding_cell_htlc_updates.len();
let commitment_tx_info = CommitmentTxInfoCached {
fee,
total_pending_htlcs,
next_holder_htlc_id: match htlc.origin {
- HTLCInitiator::LocalOffered => self.next_holder_htlc_id + 1,
- HTLCInitiator::RemoteOffered => self.next_holder_htlc_id,
+ HTLCInitiator::LocalOffered => self.context.next_holder_htlc_id + 1,
+ HTLCInitiator::RemoteOffered => self.context.next_holder_htlc_id,
},
next_counterparty_htlc_id: match htlc.origin {
- HTLCInitiator::LocalOffered => self.next_counterparty_htlc_id,
- HTLCInitiator::RemoteOffered => self.next_counterparty_htlc_id + 1,
+ HTLCInitiator::LocalOffered => self.context.next_counterparty_htlc_id,
+ HTLCInitiator::RemoteOffered => self.context.next_counterparty_htlc_id + 1,
},
- feerate: self.feerate_per_kw,
+ feerate: self.context.feerate_per_kw,
};
- *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
+ *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
}
res
}
let (htlc_success_dust_limit, htlc_timeout_dust_limit) = if self.opt_anchors() {
(0, 0)
} else {
- (self.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
- self.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
+ (self.context.feerate_per_kw as u64 * htlc_success_tx_weight(false) / 1000,
+ self.context.feerate_per_kw as u64 * htlc_timeout_tx_weight(false) / 1000)
};
- let real_dust_limit_success_sat = htlc_success_dust_limit + self.counterparty_dust_limit_satoshis;
- let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
+ let real_dust_limit_success_sat = htlc_success_dust_limit + self.context.counterparty_dust_limit_satoshis;
+ let real_dust_limit_timeout_sat = htlc_timeout_dust_limit + self.context.counterparty_dust_limit_satoshis;
let mut addl_htlcs = 0;
if fee_spike_buffer_htlc.is_some() { addl_htlcs += 1; }
// non-dust inbound HTLCs are included (as all states imply it will be included) and only
// committed outbound HTLCs, see below.
let mut included_htlcs = 0;
- for ref htlc in self.pending_inbound_htlcs.iter() {
+ for ref htlc in self.context.pending_inbound_htlcs.iter() {
if htlc.amount_msat / 1000 <= real_dust_limit_timeout_sat {
continue
}
included_htlcs += 1;
}
- for ref htlc in self.pending_outbound_htlcs.iter() {
+ for ref htlc in self.context.pending_outbound_htlcs.iter() {
if htlc.amount_msat / 1000 <= real_dust_limit_success_sat {
continue
}
}
let num_htlcs = included_htlcs + addl_htlcs;
- let res = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs, self.opt_anchors());
+ let res = Self::commit_tx_fee_msat(self.context.feerate_per_kw, num_htlcs, self.opt_anchors());
#[cfg(any(test, fuzzing))]
{
let mut fee = res;
if fee_spike_buffer_htlc.is_some() {
- fee = Self::commit_tx_fee_msat(self.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
+ fee = Self::commit_tx_fee_msat(self.context.feerate_per_kw, num_htlcs - 1, self.opt_anchors());
}
- let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
+ let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
let commitment_tx_info = CommitmentTxInfoCached {
fee,
total_pending_htlcs,
next_holder_htlc_id: match htlc.origin {
- HTLCInitiator::LocalOffered => self.next_holder_htlc_id + 1,
- HTLCInitiator::RemoteOffered => self.next_holder_htlc_id,
+ HTLCInitiator::LocalOffered => self.context.next_holder_htlc_id + 1,
+ HTLCInitiator::RemoteOffered => self.context.next_holder_htlc_id,
},
next_counterparty_htlc_id: match htlc.origin {
- HTLCInitiator::LocalOffered => self.next_counterparty_htlc_id,
- HTLCInitiator::RemoteOffered => self.next_counterparty_htlc_id + 1,
+ HTLCInitiator::LocalOffered => self.context.next_counterparty_htlc_id,
+ HTLCInitiator::RemoteOffered => self.context.next_counterparty_htlc_id + 1,
},
- feerate: self.feerate_per_kw,
+ feerate: self.context.feerate_per_kw,
};
- *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
+ *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = Some(commitment_tx_info);
}
res
}
pub fn update_add_htlc<F, L: Deref>(&mut self, msg: &msgs::UpdateAddHTLC, mut pending_forward_status: PendingHTLCStatus, create_pending_htlc_status: F, logger: &L) -> Result<(), ChannelError>
where F: for<'a> Fn(&'a Self, PendingHTLCStatus, u16) -> PendingHTLCStatus, L::Target: Logger {
// We can't accept HTLCs sent after we've sent a shutdown.
- let local_sent_shutdown = (self.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::LocalShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
+ let local_sent_shutdown = (self.context.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::LocalShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
if local_sent_shutdown {
pending_forward_status = create_pending_htlc_status(self, pending_forward_status, 0x4000|8);
}
// If the remote has sent a shutdown prior to adding this HTLC, then they are in violation of the spec.
- let remote_sent_shutdown = (self.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::RemoteShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
+ let remote_sent_shutdown = (self.context.channel_state & (ChannelState::ChannelReady as u32 | ChannelState::RemoteShutdownSent as u32)) != (ChannelState::ChannelReady as u32);
if remote_sent_shutdown {
return Err(ChannelError::Close("Got add HTLC message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent update_add_htlc when we needed a channel_reestablish".to_owned()));
}
- if msg.amount_msat > self.channel_value_satoshis * 1000 {
+ if msg.amount_msat > self.context.channel_value_satoshis * 1000 {
return Err(ChannelError::Close("Remote side tried to send more than the total value of the channel".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.holder_htlc_minimum_msat {
- return Err(ChannelError::Close(format!("Remote side tried to send less than our minimum HTLC value. Lower limit: ({}). Actual: ({})", self.holder_htlc_minimum_msat, msg.amount_msat)));
+ 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)));
}
let inbound_stats = self.get_inbound_pending_htlc_stats(None);
let outbound_stats = self.get_outbound_pending_htlc_stats(None);
- if inbound_stats.pending_htlcs + 1 > self.holder_max_accepted_htlcs as u32 {
- return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", self.holder_max_accepted_htlcs)));
+ if inbound_stats.pending_htlcs + 1 > self.context.holder_max_accepted_htlcs as u32 {
+ return Err(ChannelError::Close(format!("Remote tried to push more than our max accepted HTLCs ({})", self.context.holder_max_accepted_htlcs)));
}
- if inbound_stats.pending_htlcs_value_msat + msg.amount_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)));
+ if inbound_stats.pending_htlcs_value_msat + msg.amount_msat > self.context.holder_max_htlc_value_in_flight_msat {
+ return Err(ChannelError::Close(format!("Remote HTLC add would put them over our max HTLC value ({})", self.context.holder_max_htlc_value_in_flight_msat)));
}
// 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
// Channel state once they will not be present in the next received commitment
// transaction).
let mut removed_outbound_total_msat = 0;
- for ref htlc in self.pending_outbound_htlcs.iter() {
+ for ref htlc in self.context.pending_outbound_htlcs.iter() {
if let OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_)) = htlc.state {
removed_outbound_total_msat += htlc.amount_msat;
} else if let OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_)) = htlc.state {
(dust_buffer_feerate * htlc_timeout_tx_weight(false) / 1000,
dust_buffer_feerate * htlc_success_tx_weight(false) / 1000)
};
- let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.counterparty_dust_limit_satoshis;
+ let exposure_dust_limit_timeout_sats = htlc_timeout_dust_limit + self.context.counterparty_dust_limit_satoshis;
if msg.amount_msat / 1000 < exposure_dust_limit_timeout_sats {
let on_counterparty_tx_dust_htlc_exposure_msat = inbound_stats.on_counterparty_tx_dust_exposure_msat + outbound_stats.on_counterparty_tx_dust_exposure_msat + msg.amount_msat;
if on_counterparty_tx_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
}
}
- let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.holder_dust_limit_satoshis;
+ let exposure_dust_limit_success_sats = htlc_success_dust_limit + self.context.holder_dust_limit_satoshis;
if msg.amount_msat / 1000 < exposure_dust_limit_success_sats {
let on_holder_tx_dust_htlc_exposure_msat = inbound_stats.on_holder_tx_dust_exposure_msat + outbound_stats.on_holder_tx_dust_exposure_msat + msg.amount_msat;
if on_holder_tx_dust_htlc_exposure_msat > self.get_max_dust_htlc_exposure_msat() {
}
let pending_value_to_self_msat =
- self.value_to_self_msat + inbound_stats.pending_htlcs_value_msat - removed_outbound_total_msat;
+ self.context.value_to_self_msat + inbound_stats.pending_htlcs_value_msat - removed_outbound_total_msat;
let pending_remote_value_msat =
- self.channel_value_satoshis * 1000 - pending_value_to_self_msat;
+ self.context.channel_value_satoshis * 1000 - pending_value_to_self_msat;
if pending_remote_value_msat < msg.amount_msat {
return Err(ChannelError::Close("Remote HTLC add would overdraw remaining funds".to_owned()));
}
return Err(ChannelError::Close("Remote HTLC add would not leave enough to pay for fees".to_owned()));
};
- if pending_remote_value_msat - msg.amount_msat - remote_commit_tx_fee_msat < self.holder_selected_channel_reserve_satoshis * 1000 {
+ if pending_remote_value_msat - msg.amount_msat - remote_commit_tx_fee_msat < self.context.holder_selected_channel_reserve_satoshis * 1000 {
return Err(ChannelError::Close("Remote HTLC add would put them under remote reserve value".to_owned()));
}
// sensitive to fee spikes.
let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
let remote_fee_cost_incl_stuck_buffer_msat = 2 * self.next_remote_commit_tx_fee_msat(htlc_candidate, Some(()));
- if pending_remote_value_msat - msg.amount_msat - self.holder_selected_channel_reserve_satoshis * 1000 < remote_fee_cost_incl_stuck_buffer_msat {
+ if pending_remote_value_msat - msg.amount_msat - self.context.holder_selected_channel_reserve_satoshis * 1000 < remote_fee_cost_incl_stuck_buffer_msat {
// Note that if the pending_forward_status is not updated here, then it's because we're already failing
// the HTLC, i.e. its status is already set to failing.
log_info!(logger, "Attempting to fail HTLC due to fee spike buffer violation in channel {}. Rebalancing is required.", log_bytes!(self.channel_id()));
// Check that they won't violate our local required channel reserve by adding this HTLC.
let htlc_candidate = HTLCCandidate::new(msg.amount_msat, HTLCInitiator::RemoteOffered);
let local_commit_tx_fee_msat = self.next_local_commit_tx_fee_msat(htlc_candidate, None);
- if self.value_to_self_msat < self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 + local_commit_tx_fee_msat {
+ if self.context.value_to_self_msat < self.context.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 + local_commit_tx_fee_msat {
return Err(ChannelError::Close("Cannot accept HTLC that would put our balance under counterparty-announced channel reserve value".to_owned()));
}
}
- if self.next_counterparty_htlc_id != msg.htlc_id {
- return Err(ChannelError::Close(format!("Remote skipped HTLC ID (skipped ID: {})", self.next_counterparty_htlc_id)));
+ 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()));
}
- if self.channel_state & ChannelState::LocalShutdownSent as u32 != 0 {
+ if self.context.channel_state & ChannelState::LocalShutdownSent as u32 != 0 {
if let PendingHTLCStatus::Forward(_) = pending_forward_status {
panic!("ChannelManager shouldn't be trying to add a forwardable HTLC after we've started closing");
}
}
// Now update local state:
- self.next_counterparty_htlc_id += 1;
- self.pending_inbound_htlcs.push(InboundHTLCOutput {
+ 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,
#[inline]
fn mark_outbound_htlc_removed(&mut self, htlc_id: u64, check_preimage: Option<PaymentPreimage>, fail_reason: Option<HTLCFailReason>) -> Result<&OutboundHTLCOutput, ChannelError> {
assert!(!(check_preimage.is_some() && fail_reason.is_some()), "cannot fail while we have a preimage");
- for htlc in self.pending_outbound_htlcs.iter_mut() {
+ for htlc in self.context.pending_outbound_htlcs.iter_mut() {
if htlc.htlc_id == htlc_id {
let outcome = match check_preimage {
None => fail_reason.into(),
}
pub fn update_fulfill_htlc(&mut self, msg: &msgs::UpdateFulfillHTLC) -> Result<(HTLCSource, u64), ChannelError> {
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Close("Got fulfill HTLC message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent update_fulfill_htlc when we needed a channel_reestablish".to_owned()));
}
}
pub fn update_fail_htlc(&mut self, msg: &msgs::UpdateFailHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Close("Got fail HTLC message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent update_fail_htlc when we needed a channel_reestablish".to_owned()));
}
}
pub fn update_fail_malformed_htlc(&mut self, msg: &msgs::UpdateFailMalformedHTLC, fail_reason: HTLCFailReason) -> Result<(), ChannelError> {
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Close("Got fail malformed HTLC message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent update_fail_malformed_htlc when we needed a channel_reestablish".to_owned()));
}
pub fn commitment_signed<L: Deref>(&mut self, msg: &msgs::CommitmentSigned, logger: &L) -> Result<Option<&ChannelMonitorUpdate>, ChannelError>
where L::Target: Logger
{
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Close("Got commitment signed message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent commitment_signed when we needed a channel_reestablish".to_owned()));
}
- if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.last_sent_closing_fee.is_some() {
+ if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && 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()));
}
let funding_script = self.get_funding_redeemscript();
- let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
+ let keys = self.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
- let commitment_stats = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, logger);
+ let commitment_stats = self.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, false, logger);
let commitment_txid = {
let trusted_tx = commitment_stats.tx.trust();
let bitcoin_tx = trusted_tx.built_transaction();
- let sighash = bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
+ let sighash = bitcoin_tx.get_sighash_all(&funding_script, self.context.channel_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!(self.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&bitcoin_tx.transaction),
log_bytes!(sighash[..]), encode::serialize_hex(&funding_script), log_bytes!(self.channel_id()));
- if let Err(_) = self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.counterparty_funding_pubkey()) {
+ if let Err(_) = self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.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.
- let update_fee = if let Some((_, update_state)) = self.pending_update_fee {
+ let update_fee = if let Some((_, update_state)) = self.context.pending_update_fee {
update_state == FeeUpdateState::RemoteAnnounced
} else { false };
if update_fee {
debug_assert!(!self.is_outbound());
- let counterparty_reserve_we_require_msat = self.holder_selected_channel_reserve_satoshis * 1000;
+ let counterparty_reserve_we_require_msat = self.context.holder_selected_channel_reserve_satoshis * 1000;
if commitment_stats.remote_balance_msat < commitment_stats.total_fee_sat * 1000 + counterparty_reserve_we_require_msat {
return Err(ChannelError::Close("Funding remote cannot afford proposed new fee".to_owned()));
}
#[cfg(any(test, fuzzing))]
{
if self.is_outbound() {
- let projected_commit_tx_info = self.next_local_commitment_tx_fee_info_cached.lock().unwrap().take();
- *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
+ let projected_commit_tx_info = self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap().take();
+ *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
if let Some(info) = projected_commit_tx_info {
- let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len()
- + self.holding_cell_htlc_updates.len();
+ let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len()
+ + self.context.holding_cell_htlc_updates.len();
if info.total_pending_htlcs == total_pending_htlcs
- && info.next_holder_htlc_id == self.next_holder_htlc_id
- && info.next_counterparty_htlc_id == self.next_counterparty_htlc_id
- && info.feerate == self.feerate_per_kw {
+ && info.next_holder_htlc_id == self.context.next_holder_htlc_id
+ && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
+ && info.feerate == self.context.feerate_per_kw {
assert_eq!(commitment_stats.total_fee_sat, info.fee / 1000);
}
}
log_trace!(logger, "Checking HTLC tx signature {} by key {} against tx {} (sighash {}) with redeemscript {} in channel {}.",
log_bytes!(msg.htlc_signatures[idx].serialize_compact()[..]), log_bytes!(keys.countersignatory_htlc_key.serialize()),
encode::serialize_hex(&htlc_tx), log_bytes!(htlc_sighash[..]), encode::serialize_hex(&htlc_redeemscript), log_bytes!(self.channel_id()));
- if let Err(_) = self.secp_ctx.verify_ecdsa(&htlc_sighash, &msg.htlc_signatures[idx], &keys.countersignatory_htlc_key) {
+ if let Err(_) = self.context.secp_ctx.verify_ecdsa(&htlc_sighash, &msg.htlc_signatures[idx], &keys.countersignatory_htlc_key) {
return Err(ChannelError::Close("Invalid HTLC tx signature from peer".to_owned()));
}
if !separate_nondust_htlc_sources {
self.counterparty_funding_pubkey()
);
- self.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
+ self.context.holder_signer.validate_holder_commitment(&holder_commitment_tx, commitment_stats.preimages)
.map_err(|_| ChannelError::Close("Failed to validate our commitment".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.pending_update_fee {
+ 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.pending_inbound_htlcs.iter_mut() {
+ for htlc in self.context.pending_inbound_htlcs.iter_mut() {
let new_forward = if let &InboundHTLCState::RemoteAnnounced(ref forward_info) = &htlc.state {
Some(forward_info.clone())
} else { None };
if let Some(forward_info) = new_forward {
log_trace!(logger, "Updating HTLC {} to AwaitingRemoteRevokeToAnnounce due to commitment_signed in channel {}.",
- log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
+ log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
htlc.state = InboundHTLCState::AwaitingRemoteRevokeToAnnounce(forward_info);
need_commitment = true;
}
}
let mut claimed_htlcs = Vec::new();
- for htlc in self.pending_outbound_htlcs.iter_mut() {
+ 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 {}.",
- log_bytes!(htlc.payment_hash.0), log_bytes!(self.channel_id));
+ log_bytes!(htlc.payment_hash.0), log_bytes!(self.context.channel_id));
// Grab the preimage, if it exists, instead of cloning
let mut reason = OutboundHTLCOutcome::Success(None);
mem::swap(outcome, &mut reason);
}
}
- self.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let mut monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
commitment_tx: holder_commitment_tx,
htlc_outputs: htlcs_and_sigs,
}]
};
- self.cur_holder_commitment_transaction_number -= 1;
+ self.context.cur_holder_commitment_transaction_number -= 1;
// Note that if we need_commitment & !AwaitingRemoteRevoke we'll call
// build_commitment_no_status_check() next which will reset this to RAAFirst.
- self.resend_order = RAACommitmentOrder::CommitmentFirst;
+ self.context.resend_order = RAACommitmentOrder::CommitmentFirst;
- if (self.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0 {
+ if (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0 {
// In case we initially failed monitor updating without requiring a response, we need
// to make sure the RAA gets sent first.
- self.monitor_pending_revoke_and_ack = true;
- if need_commitment && (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
+ self.context.monitor_pending_revoke_and_ack = true;
+ if need_commitment && (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
// 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
// includes the right HTLCs.
- self.monitor_pending_commitment_signed = true;
+ 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.latest_monitor_update_id = monitor_update.update_id;
+ 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 in channel {}, updated HTLC state but awaiting a monitor update resolution to reply.",
- log_bytes!(self.channel_id));
+ log_bytes!(self.context.channel_id));
return Ok(self.push_ret_blockable_mon_update(monitor_update));
}
- let need_commitment_signed = if need_commitment && (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
+ let need_commitment_signed = if need_commitment && (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == 0 {
// 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.latest_monitor_update_id = monitor_update.update_id;
+ self.context.latest_monitor_update_id = monitor_update.update_id;
monitor_update.updates.append(&mut additional_update.updates);
true
} else { false };
/// 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<L: Deref>(&mut self, logger: &L) -> (Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
- if self.channel_state >= ChannelState::ChannelReady as u32 &&
- (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) == 0 {
+ if self.context.channel_state >= ChannelState::ChannelReady as u32 &&
+ (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)) == 0 {
self.free_holding_cell_htlcs(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<L: Deref>(&mut self, logger: &L) -> (Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>) where L::Target: Logger {
- assert_eq!(self.channel_state & ChannelState::MonitorUpdateInProgress as u32, 0);
- if self.holding_cell_htlc_updates.len() != 0 || self.holding_cell_update_fee.is_some() {
- log_trace!(logger, "Freeing holding cell with {} HTLC updates{} in channel {}", self.holding_cell_htlc_updates.len(),
- if self.holding_cell_update_fee.is_some() { " and a fee update" } else { "" }, log_bytes!(self.channel_id()));
+ assert_eq!(self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32, 0);
+ 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{} in channel {}", self.context.holding_cell_htlc_updates.len(),
+ if self.context.holding_cell_update_fee.is_some() { " and a fee update" } else { "" }, log_bytes!(self.channel_id()));
let mut monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id + 1, // We don't increment this yet!
+ update_id: self.context.latest_monitor_update_id + 1, // We don't increment this yet!
updates: Vec::new(),
};
let mut htlc_updates = Vec::new();
- mem::swap(&mut htlc_updates, &mut self.holding_cell_htlc_updates);
+ mem::swap(&mut htlc_updates, &mut self.context.holding_cell_htlc_updates);
let mut update_add_htlcs = Vec::with_capacity(htlc_updates.len());
let mut update_fulfill_htlcs = Vec::with_capacity(htlc_updates.len());
let mut update_fail_htlcs = Vec::with_capacity(htlc_updates.len());
},
}
}
- if update_add_htlcs.is_empty() && update_fulfill_htlcs.is_empty() && update_fail_htlcs.is_empty() && self.holding_cell_update_fee.is_none() {
+ if update_add_htlcs.is_empty() && update_fulfill_htlcs.is_empty() && update_fail_htlcs.is_empty() && self.context.holding_cell_update_fee.is_none() {
return (None, htlcs_to_fail);
}
- let update_fee = if let Some(feerate) = self.holding_cell_update_fee.take() {
+ let update_fee = if let Some(feerate) = self.context.holding_cell_update_fee.take() {
self.send_update_fee(feerate, false, logger)
} else {
None
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.latest_monitor_update_id = monitor_update.update_id;
+ self.context.latest_monitor_update_id = monitor_update.update_id;
monitor_update.updates.append(&mut additional_update.updates);
log_debug!(logger, "Freeing holding cell in channel {} resulted in {}{} HTLCs added, {} HTLCs fulfilled, and {} HTLCs failed.",
pub fn revoke_and_ack<L: Deref>(&mut self, msg: &msgs::RevokeAndACK, logger: &L) -> Result<(Vec<(HTLCSource, PaymentHash)>, Option<&ChannelMonitorUpdate>), ChannelError>
where L::Target: Logger,
{
- if (self.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Close("Got revoke/ACK message when channel was not in an operational state".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent revoke_and_ack when we needed a channel_reestablish".to_owned()));
}
- if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && self.last_sent_closing_fee.is_some() {
+ if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK == BOTH_SIDES_SHUTDOWN_MASK && 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_prev_commitment_point) = self.counterparty_prev_commitment_point {
- if PublicKey::from_secret_key(&self.secp_ctx, &secret) != counterparty_prev_commitment_point {
+ if let Some(counterparty_prev_commitment_point) = self.context.counterparty_prev_commitment_point {
+ if PublicKey::from_secret_key(&self.context.secp_ctx, &secret) != counterparty_prev_commitment_point {
return Err(ChannelError::Close("Got a revoke commitment secret which didn't correspond to their current pubkey".to_owned()));
}
}
- if self.channel_state & ChannelState::AwaitingRemoteRevoke as u32 == 0 {
+ if self.context.channel_state & ChannelState::AwaitingRemoteRevoke as u32 == 0 {
// 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
#[cfg(any(test, fuzzing))]
{
- *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
- *self.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
+ *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
+ *self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap() = None;
}
- self.holder_signer.validate_counterparty_revocation(
- self.cur_counterparty_commitment_transaction_number + 1,
+ self.context.holder_signer.validate_counterparty_revocation(
+ self.context.cur_counterparty_commitment_transaction_number + 1,
&secret
).map_err(|_| ChannelError::Close("Failed to validate revocation from peer".to_owned()))?;
- self.commitment_secrets.provide_secret(self.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
+ self.context.commitment_secrets.provide_secret(self.context.cur_counterparty_commitment_transaction_number + 1, msg.per_commitment_secret)
.map_err(|_| ChannelError::Close("Previous secrets did not match new one".to_owned()))?;
- self.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let mut monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::CommitmentSecret {
- idx: self.cur_counterparty_commitment_transaction_number + 1,
+ idx: self.context.cur_counterparty_commitment_transaction_number + 1,
secret: msg.per_commitment_secret,
}],
};
// (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.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32);
- self.sent_message_awaiting_response = None;
- self.counterparty_prev_commitment_point = self.counterparty_cur_commitment_point;
- self.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
- self.cur_counterparty_commitment_transaction_number -= 1;
+ self.context.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32);
+ self.context.sent_message_awaiting_response = None;
+ self.context.counterparty_prev_commitment_point = self.context.counterparty_cur_commitment_point;
+ self.context.counterparty_cur_commitment_point = Some(msg.next_per_commitment_point);
+ self.context.cur_counterparty_commitment_transaction_number -= 1;
- if self.announcement_sigs_state == AnnouncementSigsState::Committed {
- self.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
+ if self.context.announcement_sigs_state == AnnouncementSigsState::Committed {
+ self.context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
}
log_trace!(logger, "Updating HTLCs on receipt of RAA in channel {}...", log_bytes!(self.channel_id()));
let mut value_to_self_msat_diff: i64 = 0;
{
- // Take references explicitly so that we can hold multiple references to self.
- let pending_inbound_htlcs: &mut Vec<_> = &mut self.pending_inbound_htlcs;
- let pending_outbound_htlcs: &mut Vec<_> = &mut self.pending_outbound_htlcs;
+ // 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;
// We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
pending_inbound_htlcs.retain(|htlc| {
}
}
}
- self.value_to_self_msat = (self.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
+ self.context.value_to_self_msat = (self.context.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
- if let Some((feerate, update_state)) = self.pending_update_fee {
+ if let Some((feerate, update_state)) = self.context.pending_update_fee {
match update_state {
FeeUpdateState::Outbound => {
debug_assert!(self.is_outbound());
log_trace!(logger, " ...promoting outbound fee update {} to Committed", feerate);
- self.feerate_per_kw = feerate;
- self.pending_update_fee = None;
+ self.context.feerate_per_kw = feerate;
+ self.context.pending_update_fee = None;
},
FeeUpdateState::RemoteAnnounced => { debug_assert!(!self.is_outbound()); },
FeeUpdateState::AwaitingRemoteRevokeToAnnounce => {
debug_assert!(!self.is_outbound());
log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
require_commitment = true;
- self.feerate_per_kw = feerate;
- self.pending_update_fee = None;
+ self.context.feerate_per_kw = feerate;
+ self.context.pending_update_fee = None;
},
}
}
- if (self.channel_state & ChannelState::MonitorUpdateInProgress as u32) == ChannelState::MonitorUpdateInProgress as u32 {
+ if (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) == ChannelState::MonitorUpdateInProgress as u32 {
// We can't actually generate a new commitment transaction (incl by freeing holding
// cells) while we can't update the monitor, so we just return what we have.
if require_commitment {
- self.monitor_pending_commitment_signed = true;
+ self.context.monitor_pending_commitment_signed = true;
// When the monitor updating is restored we'll call get_last_commitment_update(),
// 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.latest_monitor_update_id = monitor_update.update_id;
+ self.context.latest_monitor_update_id = monitor_update.update_id;
monitor_update.updates.append(&mut additional_update.updates);
}
- self.monitor_pending_forwards.append(&mut to_forward_infos);
- self.monitor_pending_failures.append(&mut revoked_htlcs);
- self.monitor_pending_finalized_fulfills.append(&mut finalized_claimed_htlcs);
+ self.context.monitor_pending_forwards.append(&mut to_forward_infos);
+ self.context.monitor_pending_failures.append(&mut revoked_htlcs);
+ self.context.monitor_pending_finalized_fulfills.append(&mut finalized_claimed_htlcs);
log_debug!(logger, "Received a valid revoke_and_ack for channel {} but awaiting a monitor update resolution to reply.", log_bytes!(self.channel_id()));
return Ok((Vec::new(), self.push_ret_blockable_mon_update(monitor_update)));
}
match self.free_holding_cell_htlcs(logger) {
(Some(_), htlcs_to_fail) => {
- let mut additional_update = self.pending_monitor_updates.pop().unwrap().update;
+ let mut additional_update = self.context.pending_monitor_updates.pop().unwrap().update;
// 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.latest_monitor_update_id = monitor_update.update_id;
+ self.context.latest_monitor_update_id = monitor_update.update_id;
monitor_update.updates.append(&mut additional_update.updates);
self.monitor_updating_paused(false, true, false, to_forward_infos, revoked_htlcs, finalized_claimed_htlcs);
// 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.latest_monitor_update_id = monitor_update.update_id;
+ 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 for channel {}. Responding with a commitment update with {} HTLCs failed.",
// Before proposing a feerate update, check that we can actually afford the new fee.
let inbound_stats = self.get_inbound_pending_htlc_stats(Some(feerate_per_kw));
let outbound_stats = self.get_outbound_pending_htlc_stats(Some(feerate_per_kw));
- let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number);
- let commitment_stats = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, true, logger);
+ let keys = self.build_holder_transaction_keys(self.context.cur_holder_commitment_transaction_number);
+ let commitment_stats = self.build_commitment_transaction(self.context.cur_holder_commitment_transaction_number, &keys, true, true, logger);
let buffer_fee_msat = Channel::<Signer>::commit_tx_fee_sat(feerate_per_kw, commitment_stats.num_nondust_htlcs + outbound_stats.on_holder_tx_holding_cell_htlcs_count as usize + CONCURRENT_INBOUND_HTLC_FEE_BUFFER as usize, self.opt_anchors()) * 1000;
let holder_balance_msat = commitment_stats.local_balance_msat - outbound_stats.holding_cell_msat;
- if holder_balance_msat < buffer_fee_msat + self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000 {
+ if holder_balance_msat < buffer_fee_msat + self.context.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 None;
return None;
}
- if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
+ if (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0 {
force_holding_cell = true;
}
if force_holding_cell {
- self.holding_cell_update_fee = Some(feerate_per_kw);
+ self.context.holding_cell_update_fee = Some(feerate_per_kw);
return None;
}
- debug_assert!(self.pending_update_fee.is_none());
- self.pending_update_fee = Some((feerate_per_kw, FeeUpdateState::Outbound));
+ 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.channel_id,
+ channel_id: self.context.channel_id,
feerate_per_kw,
})
}
/// No further message handling calls may be made until a channel_reestablish dance has
/// completed.
pub fn remove_uncommitted_htlcs_and_mark_paused<L: Deref>(&mut self, logger: &L) where L::Target: Logger {
- assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
- if self.channel_state < ChannelState::FundingSent as u32 {
- self.channel_state = ChannelState::ShutdownComplete as u32;
+ assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
+ if self.context.channel_state < ChannelState::FundingSent as u32 {
+ self.context.channel_state = ChannelState::ShutdownComplete as u32;
return;
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == (ChannelState::PeerDisconnected as u32) {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == (ChannelState::PeerDisconnected as u32) {
// 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;
}
- if self.announcement_sigs_state == AnnouncementSigsState::MessageSent || self.announcement_sigs_state == AnnouncementSigsState::Committed {
- self.announcement_sigs_state = AnnouncementSigsState::NotSent;
+ 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.last_sent_closing_fee = None;
- self.pending_counterparty_closing_signed = None;
- self.closing_fee_limits = None;
+ 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.pending_inbound_htlcs.retain(|htlc| {
+ 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.
},
}
});
- self.next_counterparty_htlc_id -= inbound_drop_count;
+ self.context.next_counterparty_htlc_id -= inbound_drop_count;
- if let Some((_, update_state)) = self.pending_update_fee {
+ if let Some((_, update_state)) = self.context.pending_update_fee {
if update_state == FeeUpdateState::RemoteAnnounced {
debug_assert!(!self.is_outbound());
- self.pending_update_fee = None;
+ self.context.pending_update_fee = None;
}
}
- for htlc in self.pending_outbound_htlcs.iter_mut() {
+ 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
}
}
- self.sent_message_awaiting_response = None;
+ self.context.sent_message_awaiting_response = None;
- self.channel_state |= ChannelState::PeerDisconnected as u32;
+ self.context.channel_state |= ChannelState::PeerDisconnected as u32;
log_trace!(logger, "Peer disconnection resulted in {} remote-announced HTLC drops on channel {}", inbound_drop_count, log_bytes!(self.channel_id()));
}
mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
mut pending_finalized_claimed_htlcs: Vec<HTLCSource>
) {
- self.monitor_pending_revoke_and_ack |= resend_raa;
- self.monitor_pending_commitment_signed |= resend_commitment;
- self.monitor_pending_channel_ready |= resend_channel_ready;
- self.monitor_pending_forwards.append(&mut pending_forwards);
- self.monitor_pending_failures.append(&mut pending_fails);
- self.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
- self.channel_state |= ChannelState::MonitorUpdateInProgress as u32;
+ 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.append(&mut pending_forwards);
+ self.context.monitor_pending_failures.append(&mut pending_fails);
+ self.context.monitor_pending_finalized_fulfills.append(&mut pending_finalized_claimed_htlcs);
+ self.context.channel_state |= ChannelState::MonitorUpdateInProgress as u32;
}
/// Indicates that the latest ChannelMonitor update has been committed by the client
L::Target: Logger,
NS::Target: NodeSigner
{
- assert_eq!(self.channel_state & ChannelState::MonitorUpdateInProgress as u32, ChannelState::MonitorUpdateInProgress as u32);
- self.channel_state &= !(ChannelState::MonitorUpdateInProgress as u32);
+ assert_eq!(self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32, ChannelState::MonitorUpdateInProgress as u32);
+ self.context.channel_state &= !(ChannelState::MonitorUpdateInProgress as u32);
let mut found_blocked = false;
- self.pending_monitor_updates.retain(|upd| {
+ self.context.pending_monitor_updates.retain(|upd| {
if found_blocked { debug_assert!(upd.blocked, "No mons may be unblocked after a blocked one"); }
if upd.blocked { found_blocked = true; }
upd.blocked
// (re-)broadcast the funding transaction as we may have declined to broadcast it when we
// first received the funding_signed.
let mut funding_broadcastable =
- if self.is_outbound() && self.channel_state & !MULTI_STATE_FLAGS >= ChannelState::FundingSent as u32 {
- self.funding_transaction.take()
+ if self.is_outbound() && self.context.channel_state & !MULTI_STATE_FLAGS >= ChannelState::FundingSent as u32 {
+ self.context.funding_transaction.take()
} else { None };
// That said, if the funding transaction is already confirmed (ie we're active with a
// minimum_depth over 0) don't bother re-broadcasting the confirmed funding tx.
- if self.channel_state & !MULTI_STATE_FLAGS >= ChannelState::ChannelReady as u32 && self.minimum_depth != Some(0) {
+ if self.context.channel_state & !MULTI_STATE_FLAGS >= ChannelState::ChannelReady as u32 && self.context.minimum_depth != Some(0) {
funding_broadcastable = None;
}
// * 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.monitor_pending_channel_ready {
- assert!(!self.is_outbound() || self.minimum_depth == Some(0),
+ let channel_ready = if self.context.monitor_pending_channel_ready {
+ assert!(!self.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.monitor_pending_channel_ready = false;
- let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+ self.context.monitor_pending_channel_ready = false;
+ let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
Some(msgs::ChannelReady {
channel_id: self.channel_id(),
next_per_commitment_point,
- short_channel_id_alias: Some(self.outbound_scid_alias),
+ short_channel_id_alias: Some(self.context.outbound_scid_alias),
})
} else { None };
let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block_height, logger);
let mut accepted_htlcs = Vec::new();
- mem::swap(&mut accepted_htlcs, &mut self.monitor_pending_forwards);
+ mem::swap(&mut accepted_htlcs, &mut self.context.monitor_pending_forwards);
let mut failed_htlcs = Vec::new();
- mem::swap(&mut failed_htlcs, &mut self.monitor_pending_failures);
+ mem::swap(&mut failed_htlcs, &mut self.context.monitor_pending_failures);
let mut finalized_claimed_htlcs = Vec::new();
- mem::swap(&mut finalized_claimed_htlcs, &mut self.monitor_pending_finalized_fulfills);
+ mem::swap(&mut finalized_claimed_htlcs, &mut self.context.monitor_pending_finalized_fulfills);
- if self.channel_state & (ChannelState::PeerDisconnected as u32) != 0 {
- self.monitor_pending_revoke_and_ack = false;
- self.monitor_pending_commitment_signed = false;
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) != 0 {
+ self.context.monitor_pending_revoke_and_ack = false;
+ self.context.monitor_pending_commitment_signed = false;
return MonitorRestoreUpdates {
raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
accepted_htlcs, failed_htlcs, finalized_claimed_htlcs, funding_broadcastable, channel_ready, announcement_sigs
};
}
- let raa = if self.monitor_pending_revoke_and_ack {
+ let raa = if self.context.monitor_pending_revoke_and_ack {
Some(self.get_last_revoke_and_ack())
} else { None };
- let commitment_update = if self.monitor_pending_commitment_signed {
+ let commitment_update = if self.context.monitor_pending_commitment_signed {
self.mark_awaiting_response();
Some(self.get_last_commitment_update(logger))
} else { None };
- self.monitor_pending_revoke_and_ack = false;
- self.monitor_pending_commitment_signed = false;
- let order = self.resend_order.clone();
+ self.context.monitor_pending_revoke_and_ack = false;
+ self.context.monitor_pending_commitment_signed = false;
+ let order = self.context.resend_order.clone();
log_debug!(logger, "Restored monitor updating in channel {} resulting in {}{} commitment update and {} RAA, with {} first",
log_bytes!(self.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" },
if self.is_outbound() {
return Err(ChannelError::Close("Non-funding remote tried to update channel fee".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent update_fee when we needed a channel_reestablish".to_owned()));
}
- Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, Some(self.feerate_per_kw), logger)?;
+ Channel::<Signer>::check_remote_fee(fee_estimator, msg.feerate_per_kw, Some(self.context.feerate_per_kw), logger)?;
let feerate_over_dust_buffer = msg.feerate_per_kw > self.get_dust_buffer_feerate(None);
- self.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
- self.update_time_counter += 1;
+ self.context.pending_update_fee = Some((msg.feerate_per_kw, FeeUpdateState::RemoteAnnounced));
+ self.context.update_time_counter += 1;
// If the feerate has increased over the previous dust buffer (note that
// `get_dust_buffer_feerate` considers the `pending_update_fee` status), check that we
// won't be pushed over our dust exposure limit by the feerate increase.
}
fn get_last_revoke_and_ack(&self) -> msgs::RevokeAndACK {
- let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
- let per_commitment_secret = self.holder_signer.release_commitment_secret(self.cur_holder_commitment_transaction_number + 2);
+ let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
+ let per_commitment_secret = self.context.holder_signer.release_commitment_secret(self.context.cur_holder_commitment_transaction_number + 2);
msgs::RevokeAndACK {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
per_commitment_secret,
next_per_commitment_point,
#[cfg(taproot)]
let mut update_fail_htlcs = Vec::new();
let mut update_fail_malformed_htlcs = Vec::new();
- for htlc in self.pending_outbound_htlcs.iter() {
+ 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.channel_id(),
}
}
- for htlc in self.pending_inbound_htlcs.iter() {
+ for htlc in self.context.pending_inbound_htlcs.iter() {
if let &InboundHTLCState::LocalRemoved(ref reason) = &htlc.state {
match reason {
&InboundHTLCRemovalReason::FailRelay(ref err_packet) => {
}
}
- let update_fee = if self.is_outbound() && self.pending_update_fee.is_some() {
+ let update_fee = if self.is_outbound() && self.context.pending_update_fee.is_some() {
Some(msgs::UpdateFee {
channel_id: self.channel_id(),
- feerate_per_kw: self.pending_update_fee.unwrap().0,
+ feerate_per_kw: self.context.pending_update_fee.unwrap().0,
})
} else { None };
L::Target: Logger,
NS::Target: NodeSigner
{
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
// 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.
}
if msg.next_remote_commitment_number > 0 {
- let expected_point = self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.secp_ctx);
+ let expected_point = self.context.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - msg.next_remote_commitment_number + 1, &self.context.secp_ctx);
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 expected_point != PublicKey::from_secret_key(&self.secp_ctx, &given_secret) {
+ 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()));
}
- if msg.next_remote_commitment_number > INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number {
+ if msg.next_remote_commitment_number > INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number {
macro_rules! log_and_panic {
($err_msg: expr) => {
- log_error!(logger, $err_msg, log_bytes!(self.channel_id), log_pubkey!(self.counterparty_node_id));
- panic!($err_msg, log_bytes!(self.channel_id), log_pubkey!(self.counterparty_node_id));
+ log_error!(logger, $err_msg, log_bytes!(self.context.channel_id), log_pubkey!(self.context.counterparty_node_id));
+ panic!($err_msg, log_bytes!(self.context.channel_id), log_pubkey!(self.context.counterparty_node_id));
}
}
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\
// 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.
- let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number - 1;
+ let our_commitment_transaction = INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number - 1;
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.channel_state &= !(ChannelState::PeerDisconnected as u32);
- self.sent_message_awaiting_response = None;
+ self.context.channel_state &= !(ChannelState::PeerDisconnected as u32);
+ self.context.sent_message_awaiting_response = None;
- let shutdown_msg = if self.channel_state & (ChannelState::LocalShutdownSent as u32) != 0 {
- assert!(self.shutdown_scriptpubkey.is_some());
+ let shutdown_msg = if self.context.channel_state & (ChannelState::LocalShutdownSent as u32) != 0 {
+ assert!(self.context.shutdown_scriptpubkey.is_some());
Some(msgs::Shutdown {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
scriptpubkey: self.get_closing_scriptpubkey(),
})
} else { None };
let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, best_block.height(), logger);
- if self.channel_state & (ChannelState::FundingSent as u32) == ChannelState::FundingSent as u32 {
+ if self.context.channel_state & (ChannelState::FundingSent as u32) == ChannelState::FundingSent as u32 {
// If we're waiting on a monitor update, we shouldn't re-send any channel_ready's.
- if self.channel_state & (ChannelState::OurChannelReady as u32) == 0 ||
- self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
+ if self.context.channel_state & (ChannelState::OurChannelReady as u32) == 0 ||
+ self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
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()));
}
}
// We have OurChannelReady set!
- let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+ let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
return Ok(ReestablishResponses {
channel_ready: Some(msgs::ChannelReady {
channel_id: self.channel_id(),
next_per_commitment_point,
- short_channel_id_alias: Some(self.outbound_scid_alias),
+ short_channel_id_alias: Some(self.context.outbound_scid_alias),
}),
raa: None, commitment_update: None,
order: RAACommitmentOrder::CommitmentFirst,
});
}
- let required_revoke = if msg.next_remote_commitment_number + 1 == INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number {
+ let required_revoke = if msg.next_remote_commitment_number + 1 == INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number {
// 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.
None
- } else if msg.next_remote_commitment_number + 1 == (INITIAL_COMMITMENT_NUMBER - 1) - self.cur_holder_commitment_transaction_number {
- if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
- self.monitor_pending_revoke_and_ack = true;
+ } else if msg.next_remote_commitment_number + 1 == (INITIAL_COMMITMENT_NUMBER - 1) - self.context.cur_holder_commitment_transaction_number {
+ if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
+ self.context.monitor_pending_revoke_and_ack = true;
None
} else {
Some(self.get_last_revoke_and_ack())
// 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.channel_state & ChannelState::AwaitingRemoteRevoke as u32 != 0;
+ let is_awaiting_remote_revoke = self.context.channel_state & ChannelState::AwaitingRemoteRevoke as u32 != 0;
if is_awaiting_remote_revoke && !self.is_awaiting_monitor_update() {
self.mark_awaiting_response();
}
- let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.cur_counterparty_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };
+ let next_counterparty_commitment_number = INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number + if is_awaiting_remote_revoke { 1 } else { 0 };
- let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.cur_holder_commitment_transaction_number == 1 {
+ let channel_ready = if msg.next_local_commitment_number == 1 && INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_transaction_number == 1 {
// We should never have to worry about MonitorUpdateInProgress resending ChannelReady
- let next_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+ let next_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
Some(msgs::ChannelReady {
channel_id: self.channel_id(),
next_per_commitment_point,
- short_channel_id_alias: Some(self.outbound_scid_alias),
+ short_channel_id_alias: Some(self.context.outbound_scid_alias),
})
} else { None };
channel_ready, shutdown_msg, announcement_sigs,
raa: required_revoke,
commitment_update: None,
- order: self.resend_order.clone(),
+ order: self.context.resend_order.clone(),
})
} else if msg.next_local_commitment_number == next_counterparty_commitment_number - 1 {
if required_revoke.is_some() {
log_debug!(logger, "Reconnected channel {} with only lost remote commitment tx", log_bytes!(self.channel_id()));
}
- if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
- self.monitor_pending_commitment_signed = true;
+ if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) != 0 {
+ self.context.monitor_pending_commitment_signed = true;
Ok(ReestablishResponses {
channel_ready, shutdown_msg, announcement_sigs,
commitment_update: None, raa: None,
- order: self.resend_order.clone(),
+ order: self.context.resend_order.clone(),
})
} else {
Ok(ReestablishResponses {
channel_ready, shutdown_msg, announcement_sigs,
raa: required_revoke,
commitment_update: Some(self.get_last_commitment_update(logger)),
- order: self.resend_order.clone(),
+ order: self.context.resend_order.clone(),
})
}
} else {
-> (u64, u64)
where F::Target: FeeEstimator
{
- if let Some((min, max)) = self.closing_fee_limits { return (min, max); }
+ 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.
// 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.target_closing_feerate_sats_per_kw {
- let min_feerate = if self.is_outbound() { target_feerate } else { cmp::min(self.feerate_per_kw, target_feerate) };
+ if let Some(target_feerate) = self.context.target_closing_feerate_sats_per_kw {
+ let min_feerate = if self.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);
}
// 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.counterparty_shutdown_scriptpubkey.as_ref().unwrap()));
+ 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.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.config.options.force_close_avoidance_max_fee_satoshis,
+ 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.channel_value_satoshis - (self.value_to_self_msat + 999) / 1000
+ self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 1000
};
- self.closing_fee_limits = Some((proposed_total_fee_satoshis, proposed_max_total_fee_satoshis));
- self.closing_fee_limits.clone().unwrap()
+ 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
/// 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.pending_inbound_htlcs.is_empty() && self.pending_outbound_htlcs.is_empty() &&
- self.channel_state &
+ self.context.pending_inbound_htlcs.is_empty() && self.context.pending_outbound_htlcs.is_empty() &&
+ self.context.channel_state &
(BOTH_SIDES_SHUTDOWN_MASK | ChannelState::AwaitingRemoteRevoke as u32 |
ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
== BOTH_SIDES_SHUTDOWN_MASK &&
- self.pending_update_fee.is_none()
+ self.context.pending_update_fee.is_none()
}
/// Checks if the closing_signed negotiation is making appropriate progress, possibly returning
/// 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.closing_signed_in_flight {
+ 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.closing_signed_in_flight = true;
+ self.context.closing_signed_in_flight = true;
}
}
Ok(())
-> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
where F::Target: FeeEstimator, L::Target: Logger
{
- if self.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
+ if self.context.last_sent_closing_fee.is_some() || !self.closing_negotiation_ready() {
return Ok((None, None));
}
if !self.is_outbound() {
- if let Some(msg) = &self.pending_counterparty_closing_signed.take() {
+ if let Some(msg) = &self.context.pending_counterparty_closing_signed.take() {
return self.closing_signed(fee_estimator, &msg);
}
return Ok((None, None));
let (our_min_fee, our_max_fee) = self.calculate_closing_fee_limits(fee_estimator);
- assert!(self.shutdown_scriptpubkey.is_some());
+ 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 sig = self.holder_signer
- .sign_closing_transaction(&closing_tx, &self.secp_ctx)
+ let sig = self.context.holder_signer
+ .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
.map_err(|()| ChannelError::Close("Failed to get signature for closing transaction.".to_owned()))?;
- self.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
+ self.context.last_sent_closing_fee = Some((total_fee_satoshis, sig.clone()));
Ok((Some(msgs::ClosingSigned {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
fee_satoshis: total_fee_satoshis,
signature: sig,
fee_range: Some(msgs::ClosingSignedFeeRange {
// [`DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`] after sending our own to them, then we'll attempt
// a reconnection.
fn mark_awaiting_response(&mut self) {
- self.sent_message_awaiting_response = Some(0);
+ self.context.sent_message_awaiting_response = Some(0);
}
/// Determines whether we should disconnect the counterparty due to not receiving a response
///
/// This should be called on every [`super::channelmanager::ChannelManager::timer_tick_occurred`].
pub fn should_disconnect_peer_awaiting_response(&mut self) -> bool {
- let ticks_elapsed = if let Some(ticks_elapsed) = self.sent_message_awaiting_response.as_mut() {
+ let ticks_elapsed = if let Some(ticks_elapsed) = self.context.sent_message_awaiting_response.as_mut() {
ticks_elapsed
} else {
// Don't disconnect when we're not waiting on a response.
) -> Result<(Option<msgs::Shutdown>, Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), ChannelError>
where SP::Target: SignerProvider
{
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent shutdown when we needed a channel_reestablish".to_owned()));
}
- if self.channel_state < ChannelState::FundingSent as u32 {
+ if self.context.channel_state < ChannelState::FundingSent as u32 {
// 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("Peer sent shutdown pre-funding generation".to_owned()));
}
- for htlc in self.pending_inbound_htlcs.iter() {
+ 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()));
}
}
- assert_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
+ assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
if !script::is_bolt2_compliant(&msg.scriptpubkey, their_features) {
return Err(ChannelError::Warn(format!("Got a nonstandard scriptpubkey ({}) from remote peer", msg.scriptpubkey.to_bytes().to_hex())));
}
- if self.counterparty_shutdown_scriptpubkey.is_some() {
- if Some(&msg.scriptpubkey) != self.counterparty_shutdown_scriptpubkey.as_ref() {
+ 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_bytes().to_hex())));
}
} else {
- self.counterparty_shutdown_scriptpubkey = Some(msg.scriptpubkey.clone());
+ 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.channel_state & ChannelState::LocalShutdownSent as u32) != ChannelState::LocalShutdownSent as u32;
+ let send_shutdown = (self.context.channel_state & ChannelState::LocalShutdownSent as u32) != ChannelState::LocalShutdownSent as u32;
- let update_shutdown_script = match self.shutdown_scriptpubkey {
+ let update_shutdown_script = match self.context.shutdown_scriptpubkey {
Some(_) => false,
None => {
assert!(send_shutdown);
if !shutdown_scriptpubkey.is_compatible(their_features) {
return Err(ChannelError::Close(format!("Provided a scriptpubkey format not accepted by peer: {}", shutdown_scriptpubkey)));
}
- self.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
+ self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
true
},
};
// From here on out, we may not fail!
- self.channel_state |= ChannelState::RemoteShutdownSent as u32;
- self.update_time_counter += 1;
+ self.context.channel_state |= ChannelState::RemoteShutdownSent as u32;
+ self.context.update_time_counter += 1;
let monitor_update = if update_shutdown_script {
- self.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
scriptpubkey: self.get_closing_scriptpubkey(),
}],
};
self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
if self.push_blockable_mon_update(monitor_update) {
- self.pending_monitor_updates.last().map(|upd| &upd.update)
+ self.context.pending_monitor_updates.last().map(|upd| &upd.update)
} else { None }
} else { None };
let shutdown = if send_shutdown {
Some(msgs::Shutdown {
- channel_id: self.channel_id,
+ 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.holding_cell_update_fee = None;
- let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
- self.holding_cell_htlc_updates.retain(|htlc_update| {
+ 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()));
}
});
- self.channel_state |= ChannelState::LocalShutdownSent as u32;
- self.update_time_counter += 1;
+ self.context.channel_state |= ChannelState::LocalShutdownSent as u32;
+ self.context.update_time_counter += 1;
Ok((shutdown, monitor_update, dropped_outbound_htlcs))
}
-> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
where F::Target: FeeEstimator
{
- if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
+ if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
return Err(ChannelError::Close("Remote end sent us a closing_signed before both sides provided a shutdown".to_owned()));
}
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
return Err(ChannelError::Close("Peer sent closing_signed when we needed a channel_reestablish".to_owned()));
}
- if !self.pending_inbound_htlcs.is_empty() || !self.pending_outbound_htlcs.is_empty() {
+ 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.is_outbound() && self.last_sent_closing_fee.is_none() {
+ if self.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.channel_state & ChannelState::MonitorUpdateInProgress as u32 != 0 {
- self.pending_counterparty_closing_signed = Some(msg.clone());
+ if self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32 != 0 {
+ self.context.pending_counterparty_closing_signed = Some(msg.clone());
return Ok((None, None));
}
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.channel_value_satoshis);
+ let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
- match self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
+ match self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, &self.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.
closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0;
- let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.channel_value_satoshis);
- secp_check!(self.secp_ctx.verify_ecdsa(&sighash, &msg.signature, self.counterparty_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
+ let sighash = closing_tx.trust().get_sighash_all(&funding_redeemscript, self.context.channel_value_satoshis);
+ secp_check!(self.context.secp_ctx.verify_ecdsa(&sighash, &msg.signature, self.counterparty_funding_pubkey()), "Invalid closing tx signature from peer".to_owned());
},
};
}
}
- assert!(self.shutdown_scriptpubkey.is_some());
- if let Some((last_fee, sig)) = self.last_sent_closing_fee {
+ assert!(self.context.shutdown_scriptpubkey.is_some());
+ if let Some((last_fee, sig)) = self.context.last_sent_closing_fee {
if last_fee == msg.fee_satoshis {
let tx = self.build_signed_closing_transaction(&mut closing_tx, &msg.signature, &sig);
- self.channel_state = ChannelState::ShutdownComplete as u32;
- self.update_time_counter += 1;
+ self.context.channel_state = ChannelState::ShutdownComplete as u32;
+ self.context.update_time_counter += 1;
return Ok((None, Some(tx)));
}
}
self.build_closing_transaction($new_fee, false)
};
- let sig = self.holder_signer
- .sign_closing_transaction(&closing_tx, &self.secp_ctx)
+ let sig = self.context.holder_signer
+ .sign_closing_transaction(&closing_tx, &self.context.secp_ctx)
.map_err(|_| ChannelError::Close("External signer refused to sign closing transaction".to_owned()))?;
let signed_tx = if $new_fee == msg.fee_satoshis {
- self.channel_state = ChannelState::ShutdownComplete as u32;
- self.update_time_counter += 1;
+ self.context.channel_state = ChannelState::ShutdownComplete as u32;
+ self.context.update_time_counter += 1;
let tx = self.build_signed_closing_transaction(&closing_tx, &msg.signature, &sig);
Some(tx)
} else { None };
- self.last_sent_closing_fee = Some((used_fee, sig.clone()));
+ self.context.last_sent_closing_fee = Some((used_fee, sig.clone()));
return Ok((Some(msgs::ClosingSigned {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
fee_satoshis: used_fee,
signature: sig,
fee_range: Some(msgs::ClosingSignedFeeRange {
if !self.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.channel_value_satoshis - (self.value_to_self_msat + 999) / 1000);
+ debug_assert_eq!(our_max_fee, self.context.channel_value_satoshis - (self.context.value_to_self_msat + 999) / 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 {
} 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.last_sent_closing_fee {
+ 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);
// Public utilities:
pub fn channel_id(&self) -> [u8; 32] {
- self.channel_id
+ self.context.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<[u8; 32]> {
- self.temporary_channel_id
+ self.context.temporary_channel_id
}
pub fn minimum_depth(&self) -> Option<u32> {
- self.minimum_depth
+ self.context.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
+ self.context.user_id
}
/// Gets the channel's type
pub fn get_channel_type(&self) -> &ChannelTypeFeatures {
- &self.channel_type
+ &self.context.channel_type
}
/// Guaranteed to be Some after both ChannelReady messages have been exchanged (and, thus,
/// is_usable() returns true).
/// Allowed in any state (including after shutdown)
pub fn get_short_channel_id(&self) -> Option<u64> {
- self.short_channel_id
+ self.context.short_channel_id
}
/// Allowed in any state (including after shutdown)
pub fn latest_inbound_scid_alias(&self) -> Option<u64> {
- self.latest_inbound_scid_alias
+ self.context.latest_inbound_scid_alias
}
/// Allowed in any state (including after shutdown)
pub fn outbound_scid_alias(&self) -> u64 {
- self.outbound_scid_alias
+ self.context.outbound_scid_alias
}
/// 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.
pub fn set_outbound_scid_alias(&mut self, outbound_scid_alias: u64) {
- assert_eq!(self.outbound_scid_alias, 0);
- self.outbound_scid_alias = outbound_scid_alias;
+ assert_eq!(self.context.outbound_scid_alias, 0);
+ self.context.outbound_scid_alias = outbound_scid_alias;
}
/// Returns the funding_txo we either got from our peer, or were given by
/// get_outbound_funding_created.
pub fn get_funding_txo(&self) -> Option<OutPoint> {
- self.channel_transaction_parameters.funding_outpoint
+ self.context.channel_transaction_parameters.funding_outpoint
}
/// Returns the block hash in which our funding transaction was confirmed.
pub fn get_funding_tx_confirmed_in(&self) -> Option<BlockHash> {
- self.funding_tx_confirmed_in
+ self.context.funding_tx_confirmed_in
}
/// 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 {
+ if self.context.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)
+ height.checked_sub(self.context.funding_tx_confirmation_height).map_or(0, |c| c + 1)
}
fn get_holder_selected_contest_delay(&self) -> u16 {
- self.channel_transaction_parameters.holder_selected_contest_delay
+ self.context.channel_transaction_parameters.holder_selected_contest_delay
}
fn get_holder_pubkeys(&self) -> &ChannelPublicKeys {
- &self.channel_transaction_parameters.holder_pubkeys
+ &self.context.channel_transaction_parameters.holder_pubkeys
}
pub fn get_counterparty_selected_contest_delay(&self) -> Option<u16> {
- self.channel_transaction_parameters.counterparty_parameters
+ self.context.channel_transaction_parameters.counterparty_parameters
.as_ref().map(|params| params.selected_contest_delay)
}
fn get_counterparty_pubkeys(&self) -> &ChannelPublicKeys {
- &self.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
+ &self.context.channel_transaction_parameters.counterparty_parameters.as_ref().unwrap().pubkeys
}
/// Allowed in any state (including after shutdown)
pub fn get_counterparty_node_id(&self) -> PublicKey {
- self.counterparty_node_id
+ self.context.counterparty_node_id
}
/// Allowed in any state (including after shutdown)
pub fn get_holder_htlc_minimum_msat(&self) -> u64 {
- self.holder_htlc_minimum_msat
+ self.context.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) -> Option<u64> {
- self.get_htlc_maximum_msat(self.holder_max_htlc_value_in_flight_msat)
+ self.get_htlc_maximum_msat(self.context.holder_max_htlc_value_in_flight_msat)
}
/// Allowed in any state (including after shutdown)
// 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.channel_value_satoshis * 1000 * 9 / 10,
+ self.context.channel_value_satoshis * 1000 * 9 / 10,
- self.counterparty_max_htlc_value_in_flight_msat
+ self.context.counterparty_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
+ self.context.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) -> Option<u64> {
- self.get_htlc_maximum_msat(self.counterparty_max_htlc_value_in_flight_msat)
+ self.get_htlc_maximum_msat(self.context.counterparty_max_htlc_value_in_flight_msat)
}
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;
+ self.context.counterparty_selected_channel_reserve_satoshis.map(|counterparty_reserve| {
+ let holder_reserve = self.context.holder_selected_channel_reserve_satoshis;
cmp::min(
- (self.channel_value_satoshis - counterparty_reserve - holder_reserve) * 1000,
+ (self.context.channel_value_satoshis - counterparty_reserve - holder_reserve) * 1000,
party_max_htlc_value_in_flight_msat
)
})
}
pub fn get_value_satoshis(&self) -> u64 {
- self.channel_value_satoshis
+ self.context.channel_value_satoshis
}
pub fn get_fee_proportional_millionths(&self) -> u32 {
- self.config.options.forwarding_fee_proportional_millionths
+ self.context.config.options.forwarding_fee_proportional_millionths
}
pub fn get_cltv_expiry_delta(&self) -> u16 {
- cmp::max(self.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
+ cmp::max(self.context.config.options.cltv_expiry_delta, MIN_CLTV_EXPIRY_DELTA)
}
pub fn get_max_dust_htlc_exposure_msat(&self) -> u64 {
- self.config.options.max_dust_htlc_exposure_msat
+ self.context.config.options.max_dust_htlc_exposure_msat
}
/// 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)
+ self.context.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_initiated() && !self.channel_pending_event_emitted
+ self.is_funding_initiated() && !self.context.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
+ self.context.channel_pending_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;
+ self.context.channel_pending_event_emitted = true;
}
// Checks whether we should emit a `ChannelReady` event.
pub(crate) fn should_emit_channel_ready_event(&mut self) -> bool {
- self.is_usable() && !self.channel_ready_event_emitted
+ self.is_usable() && !self.context.channel_ready_event_emitted
}
// Remembers that we already emitted a `ChannelReady` event.
pub(crate) fn set_channel_ready_event_emitted(&mut self) {
- self.channel_ready_event_emitted = true;
+ self.context.channel_ready_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() {
+ if self.context.prev_config.is_none() {
return;
}
- let prev_config = self.prev_config.as_mut().unwrap();
+ let prev_config = self.context.prev_config.as_mut().unwrap();
prev_config.1 += 1;
if prev_config.1 == EXPIRE_PREV_CONFIG_TICKS {
- self.prev_config = None;
+ self.context.prev_config = None;
}
}
/// Returns the current [`ChannelConfig`] applied to the channel.
pub fn config(&self) -> ChannelConfig {
- self.config.options
+ self.context.config.options
}
/// Updates the channel's config. A bool is returned indicating whether the config update
/// applied resulted in a new ChannelUpdate message.
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;
+ self.context.config.options.forwarding_fee_proportional_millionths != config.forwarding_fee_proportional_millionths ||
+ self.context.config.options.forwarding_fee_base_msat != config.forwarding_fee_base_msat ||
+ self.context.config.options.cltv_expiry_delta != config.cltv_expiry_delta;
if did_channel_update {
- self.prev_config = Some((self.config.options, 0));
+ self.context.prev_config = Some((self.context.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.context.update_time_counter += 1;
}
- self.config.options = *config;
+ self.context.config.options = *config;
did_channel_update
}
}
pub fn get_feerate_sat_per_1000_weight(&self) -> u32 {
- self.feerate_per_kw
+ self.context.feerate_per_kw
}
pub fn get_dust_buffer_feerate(&self, outbound_feerate_update: Option<u32>) -> u32 {
// 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;
+ let mut feerate_per_kw = self.context.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 {
+ if let Some((feerate, _)) = self.context.pending_update_fee {
feerate_per_kw = cmp::max(feerate_per_kw, feerate);
}
if let Some(feerate) = outbound_feerate_update {
}
pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
- self.cur_holder_commitment_transaction_number + 1
+ self.context.cur_holder_commitment_transaction_number + 1
}
pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
- self.cur_counterparty_commitment_transaction_number + 1 - if self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 }
+ self.context.cur_counterparty_commitment_transaction_number + 1 - if self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32) != 0 { 1 } else { 0 }
}
pub fn get_revoked_counterparty_commitment_transaction_number(&self) -> u64 {
- self.cur_counterparty_commitment_transaction_number + 2
+ self.context.cur_counterparty_commitment_transaction_number + 2
}
#[cfg(test)]
pub fn get_signer(&self) -> &Signer {
- &self.holder_signer
+ &self.context.holder_signer
}
#[cfg(test)]
pub fn get_value_stat(&self) -> ChannelValueStat {
ChannelValueStat {
- value_to_self_msat: self.value_to_self_msat,
- channel_value_msat: self.channel_value_satoshis * 1000,
- channel_reserve_msat: self.counterparty_selected_channel_reserve_satoshis.unwrap() * 1000,
- pending_outbound_htlcs_amount_msat: self.pending_outbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
- pending_inbound_htlcs_amount_msat: self.pending_inbound_htlcs.iter().map(|ref h| h.amount_msat).sum::<u64>(),
+ value_to_self_msat: self.context.value_to_self_msat,
+ channel_value_msat: self.context.channel_value_satoshis * 1000,
+ channel_reserve_msat: self.context.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.holding_cell_htlc_updates.iter() {
+ 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.counterparty_max_htlc_value_in_flight_msat,
- counterparty_dust_limit_msat: self.counterparty_dust_limit_satoshis * 1000,
+ 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,
}
}
/// Allowed in any state (including after shutdown)
pub fn get_update_time_counter(&self) -> u32 {
- self.update_time_counter
+ self.context.update_time_counter
}
pub fn get_latest_monitor_update_id(&self) -> u64 {
- self.latest_monitor_update_id
+ self.context.latest_monitor_update_id
}
pub fn should_announce(&self) -> bool {
- self.config.announced_channel
+ self.context.config.announced_channel
}
pub fn is_outbound(&self) -> bool {
- self.channel_transaction_parameters.is_outbound_from_holder
+ self.context.channel_transaction_parameters.is_outbound_from_holder
}
/// 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
+ self.context.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::OurInitSent as u32)
+ self.context.channel_state > (ChannelState::OurInitSent as u32)
}
/// 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 {
let mask = ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK;
- (self.channel_state & mask) == (ChannelState::ChannelReady as u32) && !self.monitor_pending_channel_ready
+ (self.context.channel_state & mask) == (ChannelState::ChannelReady as u32) && !self.context.monitor_pending_channel_ready
}
/// 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 & (ChannelState::PeerDisconnected as u32) == 0)
+ self.is_usable() && (self.context.channel_state & (ChannelState::PeerDisconnected as u32) == 0)
}
/// 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.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0
+ (self.context.channel_state & ChannelState::MonitorUpdateInProgress as u32) != 0
}
pub fn get_latest_complete_monitor_update_id(&self) -> u64 {
- if self.pending_monitor_updates.is_empty() { return self.get_latest_monitor_update_id(); }
- self.pending_monitor_updates[0].update.update_id - 1
+ if self.context.pending_monitor_updates.is_empty() { return self.get_latest_monitor_update_id(); }
+ self.context.pending_monitor_updates[0].update.update_id - 1
}
/// 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)> {
- for i in 0..self.pending_monitor_updates.len() {
- if self.pending_monitor_updates[i].blocked {
- self.pending_monitor_updates[i].blocked = false;
- return Some((&self.pending_monitor_updates[i].update,
- self.pending_monitor_updates.len() > i + 1));
+ for i in 0..self.context.pending_monitor_updates.len() {
+ if self.context.pending_monitor_updates[i].blocked {
+ self.context.pending_monitor_updates[i].blocked = false;
+ return Some((&self.context.pending_monitor_updates[i].update,
+ self.context.pending_monitor_updates.len() > i + 1));
}
}
None
/// Pushes a new monitor update into our monitor update queue, returning whether it should be
/// immediately given to the user for persisting or if it should be held as blocked.
fn push_blockable_mon_update(&mut self, update: ChannelMonitorUpdate) -> bool {
- let release_monitor = self.pending_monitor_updates.iter().all(|upd| !upd.blocked);
- self.pending_monitor_updates.push(PendingChannelMonitorUpdate {
+ let release_monitor = self.context.pending_monitor_updates.iter().all(|upd| !upd.blocked);
+ self.context.pending_monitor_updates.push(PendingChannelMonitorUpdate {
update, blocked: !release_monitor
});
release_monitor
fn push_ret_blockable_mon_update(&mut self, update: ChannelMonitorUpdate)
-> Option<&ChannelMonitorUpdate> {
let release_monitor = self.push_blockable_mon_update(update);
- if release_monitor { self.pending_monitor_updates.last().map(|upd| &upd.update) } else { None }
+ if release_monitor { self.context.pending_monitor_updates.last().map(|upd| &upd.update) } else { None }
}
pub fn no_monitor_updates_pending(&self) -> bool {
- self.pending_monitor_updates.is_empty()
+ self.context.pending_monitor_updates.is_empty()
}
pub fn complete_all_mon_updates_through(&mut self, update_id: u64) {
- self.pending_monitor_updates.retain(|upd| {
+ self.context.pending_monitor_updates.retain(|upd| {
if upd.update.update_id <= update_id {
assert!(!upd.blocked, "Completed update must have flown");
false
}
pub fn complete_one_mon_update(&mut self, update_id: u64) {
- self.pending_monitor_updates.retain(|upd| upd.update.update_id != update_id);
+ self.context.pending_monitor_updates.retain(|upd| upd.update.update_id != update_id);
}
/// Returns an iterator over all unblocked monitor updates which have not yet completed.
pub fn uncompleted_unblocked_mon_updates(&self) -> impl Iterator<Item=&ChannelMonitorUpdate> {
- self.pending_monitor_updates.iter()
+ self.context.pending_monitor_updates.iter()
.filter_map(|upd| if upd.blocked { None } else { Some(&upd.update) })
}
/// Returns true if funding_created was sent/received.
pub fn is_funding_initiated(&self) -> bool {
- self.channel_state >= ChannelState::FundingSent as u32
+ self.context.channel_state >= ChannelState::FundingSent as u32
}
/// Returns true if the channel is awaiting the persistence of the initial ChannelMonitor.
/// advanced state.
pub fn is_awaiting_initial_mon_persist(&self) -> bool {
if !self.is_awaiting_monitor_update() { return false; }
- if self.channel_state &
+ if self.context.channel_state &
!(ChannelState::TheirChannelReady as u32 | ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32)
== ChannelState::FundingSent as u32 {
// If we're not a 0conf channel, we'll be waiting on a monitor update with only
// FundingSent set, though our peer could have sent their channel_ready.
- debug_assert!(self.minimum_depth.unwrap_or(1) > 0);
+ debug_assert!(self.context.minimum_depth.unwrap_or(1) > 0);
return true;
}
- if self.cur_holder_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 &&
- self.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
+ if self.context.cur_holder_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 &&
+ self.context.cur_counterparty_commitment_transaction_number == INITIAL_COMMITMENT_NUMBER - 1 {
// If we're a 0-conf channel, we'll move beyond FundingSent 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
// 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.is_outbound() { assert!(self.funding_transaction.is_some()); }
- assert!(self.monitor_pending_channel_ready);
- assert_eq!(self.latest_monitor_update_id, 0);
+ if self.is_outbound() { assert!(self.context.funding_transaction.is_some()); }
+ assert!(self.context.monitor_pending_channel_ready);
+ assert_eq!(self.context.latest_monitor_update_id, 0);
return true;
}
false
/// Returns true if our channel_ready has been sent
pub fn is_our_channel_ready(&self) -> bool {
- (self.channel_state & ChannelState::OurChannelReady as u32) != 0 || self.channel_state >= ChannelState::ChannelReady as u32
+ (self.context.channel_state & ChannelState::OurChannelReady as u32) != 0 || self.context.channel_state >= ChannelState::ChannelReady as u32
}
/// Returns true if our peer has either initiated or agreed to shut down the channel.
pub fn received_shutdown(&self) -> bool {
- (self.channel_state & ChannelState::RemoteShutdownSent as u32) != 0
+ (self.context.channel_state & ChannelState::RemoteShutdownSent as u32) != 0
}
/// Returns true if we either initiated or agreed to shut down the channel.
pub fn sent_shutdown(&self) -> bool {
- (self.channel_state & ChannelState::LocalShutdownSent as u32) != 0
+ (self.context.channel_state & ChannelState::LocalShutdownSent as u32) != 0
}
/// 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 {
- if (self.channel_state & ChannelState::ShutdownComplete as u32) == ChannelState::ShutdownComplete as u32 {
- assert!(self.channel_state == ChannelState::ShutdownComplete as u32);
+ if (self.context.channel_state & ChannelState::ShutdownComplete as u32) == ChannelState::ShutdownComplete as u32 {
+ assert!(self.context.channel_state == ChannelState::ShutdownComplete as u32);
true
} else { false }
}
pub fn channel_update_status(&self) -> ChannelUpdateStatus {
- self.channel_update_status
+ self.context.channel_update_status
}
pub fn set_channel_update_status(&mut self, status: ChannelUpdateStatus) {
- self.update_time_counter += 1;
- self.channel_update_status = status;
+ self.context.update_time_counter += 1;
+ self.context.channel_update_status = status;
}
fn check_get_channel_ready(&mut self, height: u32) -> 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.funding_tx_confirmation_height == 0 && self.minimum_depth != Some(0) {
+ if self.context.funding_tx_confirmation_height == 0 && self.context.minimum_depth != Some(0) {
return None;
}
- let funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
+ let funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
if funding_tx_confirmations <= 0 {
- self.funding_tx_confirmation_height = 0;
+ self.context.funding_tx_confirmation_height = 0;
}
- if funding_tx_confirmations < self.minimum_depth.unwrap_or(0) as i64 {
+ if funding_tx_confirmations < self.context.minimum_depth.unwrap_or(0) as i64 {
return None;
}
- let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
+ let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
let need_commitment_update = if non_shutdown_state == ChannelState::FundingSent as u32 {
- self.channel_state |= ChannelState::OurChannelReady as u32;
+ self.context.channel_state |= ChannelState::OurChannelReady as u32;
true
} else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::TheirChannelReady as u32) {
- self.channel_state = ChannelState::ChannelReady as u32 | (self.channel_state & MULTI_STATE_FLAGS);
- self.update_time_counter += 1;
+ self.context.channel_state = ChannelState::ChannelReady as u32 | (self.context.channel_state & MULTI_STATE_FLAGS);
+ self.context.update_time_counter += 1;
true
} else if non_shutdown_state == (ChannelState::FundingSent as u32 | ChannelState::OurChannelReady as u32) {
// We got a reorg but not enough to trigger a force close, just ignore.
false
} else {
- if self.funding_tx_confirmation_height != 0 && self.channel_state < ChannelState::ChannelReady as u32 {
+ if self.context.funding_tx_confirmation_height != 0 && self.context.channel_state < ChannelState::ChannelReady as u32 {
// 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,
#[cfg(not(fuzzing))]
panic!("Started confirming a channel in a state pre-FundingSent: {}.\n\
Do NOT broadcast a funding transaction manually - let LDK do it for you!",
- self.channel_state);
+ self.context.channel_state);
}
// We got a reorg but not enough to trigger a force close, just ignore.
false
};
if need_commitment_update {
- if self.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
- if self.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
+ if self.context.channel_state & (ChannelState::MonitorUpdateInProgress as u32) == 0 {
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32) == 0 {
let next_per_commitment_point =
- self.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.secp_ctx);
+ self.context.holder_signer.get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, &self.context.secp_ctx);
return Some(msgs::ChannelReady {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
next_per_commitment_point,
- short_channel_id_alias: Some(self.outbound_scid_alias),
+ short_channel_id_alias: Some(self.context.outbound_scid_alias),
});
}
} else {
- self.monitor_pending_channel_ready = true;
+ self.context.monitor_pending_channel_ready = true;
}
}
None
for &(index_in_block, tx) in txdata.iter() {
// 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 self.funding_tx_confirmation_height == 0 {
+ if self.context.funding_tx_confirmation_height == 0 {
if tx.txid() == funding_txo.txid {
let txo_idx = funding_txo.index as usize;
if txo_idx >= tx.output.len() || tx.output[txo_idx].script_pubkey != self.get_funding_redeemscript().to_v0_p2wsh() ||
- tx.output[txo_idx].value != self.channel_value_satoshis {
+ tx.output[txo_idx].value != self.context.channel_value_satoshis {
if self.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
#[cfg(not(fuzzing))]
panic!("Client called ChannelManager::funding_transaction_generated with bogus transaction!");
}
- self.update_time_counter += 1;
+ self.context.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 {
}
}
}
- self.funding_tx_confirmation_height = height;
- self.funding_tx_confirmed_in = Some(*block_hash);
- self.short_channel_id = match scid_from_parts(height as u64, index_in_block as u64, txo_idx as u64) {
+ self.context.funding_tx_confirmation_height = height;
+ self.context.funding_tx_confirmed_in = Some(*block_hash);
+ self.context.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"),
}
// send it immediately instead of waiting for a best_block_updated call (which
// may have already happened for this block).
if let Some(channel_ready) = self.check_get_channel_ready(height) {
- log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
+ log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.context.channel_id));
let announcement_sigs = self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger);
return Ok((Some(channel_ready), announcement_sigs));
}
// forward 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.holding_cell_htlc_updates.retain(|htlc_update| {
+ 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 {
}
});
- self.update_time_counter = cmp::max(self.update_time_counter, highest_header_time);
+ self.context.update_time_counter = cmp::max(self.context.update_time_counter, highest_header_time);
if let Some(channel_ready) = self.check_get_channel_ready(height) {
let announcement_sigs = if let Some((genesis_block_hash, node_signer, user_config)) = genesis_node_signer {
self.get_announcement_sigs(node_signer, genesis_block_hash, user_config, height, logger)
} else { None };
- log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.channel_id));
+ log_info!(logger, "Sending a channel_ready to our peer for channel {}", log_bytes!(self.context.channel_id));
return Ok((Some(channel_ready), timed_out_htlcs, announcement_sigs));
}
- let non_shutdown_state = self.channel_state & (!MULTI_STATE_FLAGS);
+ let non_shutdown_state = self.context.channel_state & (!MULTI_STATE_FLAGS);
if non_shutdown_state >= ChannelState::ChannelReady as u32 ||
(non_shutdown_state & ChannelState::OurChannelReady as u32) == ChannelState::OurChannelReady as u32 {
- let mut funding_tx_confirmations = height as i64 - self.funding_tx_confirmation_height as i64 + 1;
- if self.funding_tx_confirmation_height == 0 {
+ let mut funding_tx_confirmations = height as i64 - self.context.funding_tx_confirmation_height as i64 + 1;
+ if self.context.funding_tx_confirmation_height == 0 {
// Note that check_get_channel_ready may reset funding_tx_confirmation_height to
// zero if it has been reorged out, however in either case, our state flags
// indicate we've already sent a channel_ready
// 0-conf channel, but not doing so may lead to the
// `ChannelManager::short_to_chan_info` map being inconsistent, so we currently have
// to.
- if funding_tx_confirmations == 0 && self.funding_tx_confirmed_in.is_some() {
+ if funding_tx_confirmations == 0 && self.context.funding_tx_confirmed_in.is_some() {
let err_reason = format!("Funding transaction was un-confirmed. Locked at {} confs, now have {} confs.",
- self.minimum_depth.unwrap(), funding_tx_confirmations);
+ self.context.minimum_depth.unwrap(), funding_tx_confirmations);
return Err(ClosureReason::ProcessingError { err: err_reason });
}
- } else if !self.is_outbound() && self.funding_tx_confirmed_in.is_none() &&
- height >= self.channel_creation_height + FUNDING_CONF_DEADLINE_BLOCKS {
- log_info!(logger, "Closing channel {} due to funding timeout", log_bytes!(self.channel_id));
+ } else if !self.is_outbound() && self.context.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", log_bytes!(self.context.channel_id));
// If funding_tx_confirmed_in is unset, the channel must not be active
assert!(non_shutdown_state <= ChannelState::ChannelReady as u32);
assert_eq!(non_shutdown_state & ChannelState::OurChannelReady as u32, 0);
/// force-close the channel, but may also indicate a harmless reorganization of a block or two
/// before the channel has reached channel_ready and we can just wait for more blocks.
pub fn funding_transaction_unconfirmed<L: Deref>(&mut self, logger: &L) -> Result<(), ClosureReason> where L::Target: Logger {
- if self.funding_tx_confirmation_height != 0 {
+ if self.context.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 = self.funding_tx_confirmation_height - 1;
+ let reorg_height = self.context.funding_tx_confirmation_height - 1;
// We use the time field to bump the current time we set on channel updates if its
// larger. If we don't know that time has moved forward, we can just set it to the last
// time we saw and it will be ignored.
- let best_time = self.update_time_counter;
+ let best_time = self.context.update_time_counter;
match self.do_best_block_updated(reorg_height, best_time, None::<(BlockHash, &&NodeSigner, &UserConfig)>, logger) {
Ok((channel_ready, timed_out_htlcs, announcement_sigs)) => {
assert!(channel_ready.is_none(), "We can't generate a funding with 0 confirmations?");
if !self.is_outbound() {
panic!("Tried to open a channel for an inbound channel?");
}
- if self.channel_state != ChannelState::OurInitSent as u32 {
+ if self.context.channel_state != ChannelState::OurInitSent as u32 {
panic!("Cannot generate an open_channel after we've moved forward");
}
- if self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
+ if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
panic!("Tried to send an open_channel for a channel that has already advanced");
}
- let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+ let first_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
let keys = self.get_holder_pubkeys();
msgs::OpenChannel {
chain_hash,
- temporary_channel_id: self.channel_id,
- funding_satoshis: self.channel_value_satoshis,
- push_msat: self.channel_value_satoshis * 1000 - self.value_to_self_msat,
- dust_limit_satoshis: self.holder_dust_limit_satoshis,
- max_htlc_value_in_flight_msat: self.holder_max_htlc_value_in_flight_msat,
- channel_reserve_satoshis: self.holder_selected_channel_reserve_satoshis,
- htlc_minimum_msat: self.holder_htlc_minimum_msat,
- feerate_per_kw: self.feerate_per_kw as u32,
+ temporary_channel_id: self.context.channel_id,
+ funding_satoshis: self.context.channel_value_satoshis,
+ push_msat: self.context.channel_value_satoshis * 1000 - self.context.value_to_self_msat,
+ dust_limit_satoshis: self.context.holder_dust_limit_satoshis,
+ max_htlc_value_in_flight_msat: self.context.holder_max_htlc_value_in_flight_msat,
+ channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
+ htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
+ feerate_per_kw: self.context.feerate_per_kw as u32,
to_self_delay: self.get_holder_selected_contest_delay(),
- max_accepted_htlcs: self.holder_max_accepted_htlcs,
+ max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
funding_pubkey: keys.funding_pubkey,
revocation_basepoint: keys.revocation_basepoint,
payment_point: keys.payment_point,
delayed_payment_basepoint: keys.delayed_payment_basepoint,
htlc_basepoint: keys.htlc_basepoint,
first_per_commitment_point,
- channel_flags: if self.config.announced_channel {1} else {0},
- shutdown_scriptpubkey: Some(match &self.shutdown_scriptpubkey {
+ channel_flags: if self.context.config.announced_channel {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.channel_type.clone()),
+ channel_type: Some(self.context.channel_type.clone()),
}
}
pub fn inbound_is_awaiting_accept(&self) -> bool {
- self.inbound_awaiting_accept
+ self.context.inbound_awaiting_accept
}
/// Sets this channel to accepting 0conf, must be done before `get_accept_channel`
pub fn set_0conf(&mut self) {
- assert!(self.inbound_awaiting_accept);
- self.minimum_depth = Some(0);
+ assert!(self.context.inbound_awaiting_accept);
+ self.context.minimum_depth = Some(0);
}
/// Marks an inbound channel as accepted and generates a [`msgs::AcceptChannel`] message which
if self.is_outbound() {
panic!("Tried to send accept_channel for an outbound channel?");
}
- if self.channel_state != (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32) {
+ if self.context.channel_state != (ChannelState::OurInitSent as u32) | (ChannelState::TheirInitSent as u32) {
panic!("Tried to send accept_channel after channel had moved forward");
}
- if self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
+ if self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
panic!("Tried to send an accept_channel for a channel that has already advanced");
}
- if !self.inbound_awaiting_accept {
+ if !self.context.inbound_awaiting_accept {
panic!("The inbound channel has already been accepted");
}
- self.user_id = user_id;
- self.inbound_awaiting_accept = false;
+ self.context.user_id = user_id;
+ self.context.inbound_awaiting_accept = false;
self.generate_accept_channel_message()
}
///
/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
- let first_per_commitment_point = self.holder_signer.get_per_commitment_point(self.cur_holder_commitment_transaction_number, &self.secp_ctx);
+ let first_per_commitment_point = self.context.holder_signer.get_per_commitment_point(self.context.cur_holder_commitment_transaction_number, &self.context.secp_ctx);
let keys = self.get_holder_pubkeys();
msgs::AcceptChannel {
- temporary_channel_id: self.channel_id,
- dust_limit_satoshis: self.holder_dust_limit_satoshis,
- max_htlc_value_in_flight_msat: self.holder_max_htlc_value_in_flight_msat,
- channel_reserve_satoshis: self.holder_selected_channel_reserve_satoshis,
- htlc_minimum_msat: self.holder_htlc_minimum_msat,
- minimum_depth: self.minimum_depth.unwrap(),
+ 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,
+ channel_reserve_satoshis: self.context.holder_selected_channel_reserve_satoshis,
+ htlc_minimum_msat: self.context.holder_htlc_minimum_msat,
+ minimum_depth: self.context.minimum_depth.unwrap(),
to_self_delay: self.get_holder_selected_contest_delay(),
- max_accepted_htlcs: self.holder_max_accepted_htlcs,
+ max_accepted_htlcs: self.context.holder_max_accepted_htlcs,
funding_pubkey: keys.funding_pubkey,
revocation_basepoint: keys.revocation_basepoint,
payment_point: keys.payment_point,
delayed_payment_basepoint: keys.delayed_payment_basepoint,
htlc_basepoint: keys.htlc_basepoint,
first_per_commitment_point,
- shutdown_scriptpubkey: Some(match &self.shutdown_scriptpubkey {
+ shutdown_scriptpubkey: Some(match &self.context.shutdown_scriptpubkey {
Some(script) => script.clone().into_inner(),
None => Builder::new().into_script(),
}),
- channel_type: Some(self.channel_type.clone()),
+ channel_type: Some(self.context.channel_type.clone()),
#[cfg(taproot)]
next_local_nonce: None,
}
/// If an Err is returned, it is a ChannelError::Close (for get_outbound_funding_created)
fn get_outbound_funding_created_signature<L: Deref>(&mut self, logger: &L) -> Result<Signature, ChannelError> where L::Target: Logger {
let counterparty_keys = self.build_remote_transaction_keys();
- let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
- Ok(self.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.secp_ctx)
+ let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, logger).tx;
+ Ok(self.context.holder_signer.sign_counterparty_commitment(&counterparty_initial_commitment_tx, Vec::new(), &self.context.secp_ctx)
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0)
}
if !self.is_outbound() {
panic!("Tried to create outbound funding_created message on an inbound channel!");
}
- if self.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
+ if self.context.channel_state != (ChannelState::OurInitSent as u32 | ChannelState::TheirInitSent as u32) {
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)");
}
- if self.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
- self.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
- self.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
+ if self.context.commitment_secrets.get_min_seen_secret() != (1 << 48) ||
+ self.context.cur_counterparty_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER ||
+ self.context.cur_holder_commitment_transaction_number != INITIAL_COMMITMENT_NUMBER {
panic!("Should not have advanced channel commitment tx numbers prior to funding_created");
}
- self.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
- self.holder_signer.provide_channel_parameters(&self.channel_transaction_parameters);
+ self.context.channel_transaction_parameters.funding_outpoint = Some(funding_txo);
+ self.context.holder_signer.provide_channel_parameters(&self.context.channel_transaction_parameters);
let signature = match self.get_outbound_funding_created_signature(logger) {
Ok(res) => res,
Err(e) => {
log_error!(logger, "Got bad signatures: {:?}!", e);
- self.channel_transaction_parameters.funding_outpoint = None;
+ self.context.channel_transaction_parameters.funding_outpoint = None;
return Err(e);
}
};
- let temporary_channel_id = self.channel_id;
+ let temporary_channel_id = self.context.channel_id;
// Now that we're past error-generating stuff, update our local state:
- self.channel_state = ChannelState::FundingCreated as u32;
- self.channel_id = funding_txo.to_channel_id();
- self.funding_transaction = Some(funding_transaction);
+ self.context.channel_state = ChannelState::FundingCreated as u32;
+ self.context.channel_id = funding_txo.to_channel_id();
+ self.context.funding_transaction = Some(funding_transaction);
Ok(msgs::FundingCreated {
temporary_channel_id,
fn get_channel_announcement<NS: Deref>(
&self, node_signer: &NS, chain_hash: BlockHash, user_config: &UserConfig,
) -> Result<msgs::UnsignedChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
- if !self.config.announced_channel {
+ if !self.context.config.announced_channel {
return Err(ChannelError::Ignore("Channel is not available for public announcements".to_owned()));
}
if !self.is_usable() {
NS::Target: NodeSigner,
L::Target: Logger
{
- if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
+ if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
return None;
}
return None;
}
- if self.channel_state & ChannelState::PeerDisconnected as u32 != 0 {
+ if self.context.channel_state & ChannelState::PeerDisconnected as u32 != 0 {
log_trace!(logger, "Cannot create an announcement_signatures as our peer is disconnected");
return None;
}
- if self.announcement_sigs_state != AnnouncementSigsState::NotSent {
+ if self.context.announcement_sigs_state != AnnouncementSigsState::NotSent {
return None;
}
},
Ok(v) => v
};
- let our_bitcoin_sig = match self.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx) {
+ let our_bitcoin_sig = match self.context.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.context.secp_ctx) {
Err(_) => {
log_error!(logger, "Signer rejected channel_announcement signing. Channel will not be announced!");
return None;
},
Ok(v) => v
};
- self.announcement_sigs_state = AnnouncementSigsState::MessageSent;
+ self.context.announcement_sigs_state = AnnouncementSigsState::MessageSent;
Some(msgs::AnnouncementSignatures {
channel_id: self.channel_id(),
fn sign_channel_announcement<NS: Deref>(
&self, node_signer: &NS, announcement: msgs::UnsignedChannelAnnouncement
) -> Result<msgs::ChannelAnnouncement, ChannelError> where NS::Target: NodeSigner {
- if let Some((their_node_sig, their_bitcoin_sig)) = self.announcement_sigs {
+ 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.holder_signer.sign_channel_announcement_with_funding_key(&announcement, &self.secp_ctx)
+ let our_bitcoin_sig = self.context.holder_signer.sign_channel_announcement_with_funding_key(&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 },
let msghash = hash_to_message!(&Sha256d::hash(&announcement.encode()[..])[..]);
- if self.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.get_counterparty_node_id()).is_err() {
+ if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.node_signature, &self.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.get_counterparty_node_id())));
}
- if self.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.counterparty_funding_pubkey()).is_err() {
+ if self.context.secp_ctx.verify_ecdsa(&msghash, &msg.bitcoin_signature, self.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.counterparty_funding_pubkey())));
}
- self.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
- if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
+ self.context.announcement_sigs = Some((msg.node_signature, msg.bitcoin_signature));
+ if self.context.funding_tx_confirmation_height == 0 || self.context.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()));
}
pub fn get_signed_channel_announcement<NS: Deref>(
&self, node_signer: &NS, chain_hash: BlockHash, best_block_height: u32, user_config: &UserConfig
) -> Option<msgs::ChannelAnnouncement> where NS::Target: NodeSigner {
- if self.funding_tx_confirmation_height == 0 || self.funding_tx_confirmation_height + 5 > best_block_height {
+ if self.context.funding_tx_confirmation_height == 0 || self.context.funding_tx_confirmation_height + 5 > best_block_height {
return None;
}
let announcement = match self.get_channel_announcement(node_signer, chain_hash, user_config) {
/// May panic if called on a channel that wasn't immediately-previously
/// self.remove_uncommitted_htlcs_and_mark_paused()'d
pub fn get_channel_reestablish<L: Deref>(&mut self, logger: &L) -> msgs::ChannelReestablish where L::Target: Logger {
- assert_eq!(self.channel_state & ChannelState::PeerDisconnected as u32, ChannelState::PeerDisconnected as u32);
- assert_ne!(self.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
+ assert_eq!(self.context.channel_state & ChannelState::PeerDisconnected as u32, ChannelState::PeerDisconnected as u32);
+ assert_ne!(self.context.cur_counterparty_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
// 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.
// 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.cur_counterparty_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
- let remote_last_secret = self.commitment_secrets.get_secret(self.cur_counterparty_commitment_transaction_number + 2).unwrap();
+ let remote_last_secret = if self.context.cur_counterparty_commitment_transaction_number + 1 < INITIAL_COMMITMENT_NUMBER {
+ let remote_last_secret = self.context.commitment_secrets.get_secret(self.context.cur_counterparty_commitment_transaction_number + 2).unwrap();
log_trace!(logger, "Enough info to generate a Data Loss Protect with per_commitment_secret {} for channel {}", log_bytes!(remote_last_secret), log_bytes!(self.channel_id()));
remote_last_secret
} else {
// 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.cur_holder_commitment_transaction_number,
+ next_local_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_holder_commitment_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
// cur_counterparty_commitment_transaction_number is INITIAL_COMMITMENT_NUMBER we will have
// dropped this channel on disconnect as it hasn't yet reached FundingSent so we can't
// overflow here.
- next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.cur_counterparty_commitment_transaction_number - 1,
+ next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.context.cur_counterparty_commitment_transaction_number - 1,
your_last_per_commitment_secret: remote_last_secret,
my_current_per_commitment_point: dummy_pubkey,
// TODO(dual_funding): If we've sent `commtiment_signed` for an interactive transaction
fn send_htlc<L: Deref>(&mut self, amount_msat: u64, payment_hash: PaymentHash, cltv_expiry: u32, source: HTLCSource,
onion_routing_packet: msgs::OnionPacket, mut force_holding_cell: bool, logger: &L)
-> Result<Option<msgs::UpdateAddHTLC>, ChannelError> where L::Target: Logger {
- if (self.channel_state & (ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelReady as u32) {
+ if (self.context.channel_state & (ChannelState::ChannelReady as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelReady as u32) {
return Err(ChannelError::Ignore("Cannot send HTLC until channel is fully established and we haven't started shutting down".to_owned()));
}
- let channel_total_msat = self.channel_value_satoshis * 1000;
+ let channel_total_msat = self.context.channel_value_satoshis * 1000;
if amount_msat > channel_total_msat {
return Err(ChannelError::Ignore(format!("Cannot send amount {}, because it is more than the total value of the channel {}", amount_msat, channel_total_msat)));
}
available_balances.next_outbound_htlc_limit_msat)));
}
- if (self.channel_state & (ChannelState::PeerDisconnected as u32)) != 0 {
+ if (self.context.channel_state & (ChannelState::PeerDisconnected as u32)) != 0 {
// 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
return Err(ChannelError::Ignore("Cannot send an HTLC while disconnected from channel counterparty".to_owned()));
}
- let need_holding_cell = (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0;
+ let need_holding_cell = (self.context.channel_state & (ChannelState::AwaitingRemoteRevoke as u32 | ChannelState::MonitorUpdateInProgress as u32)) != 0;
log_debug!(logger, "Pushing new outbound HTLC for {} msat {}", 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" }
// Now update local state:
if force_holding_cell {
- self.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
+ self.context.holding_cell_htlc_updates.push(HTLCUpdateAwaitingACK::AddHTLC {
amount_msat,
payment_hash,
cltv_expiry,
return Ok(None);
}
- self.pending_outbound_htlcs.push(OutboundHTLCOutput {
- htlc_id: self.next_holder_htlc_id,
+ self.context.pending_outbound_htlcs.push(OutboundHTLCOutput {
+ htlc_id: self.context.next_holder_htlc_id,
amount_msat,
payment_hash: payment_hash.clone(),
cltv_expiry,
});
let res = msgs::UpdateAddHTLC {
- channel_id: self.channel_id,
- htlc_id: self.next_holder_htlc_id,
+ channel_id: self.context.channel_id,
+ htlc_id: self.context.next_holder_htlc_id,
amount_msat,
payment_hash,
cltv_expiry,
onion_routing_packet,
};
- self.next_holder_htlc_id += 1;
+ self.context.next_holder_htlc_id += 1;
Ok(Some(res))
}
// 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.pending_inbound_htlcs.iter_mut() {
+ 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 };
htlc.state = state;
}
}
- for htlc in self.pending_outbound_htlcs.iter_mut() {
+ 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", log_bytes!(htlc.payment_hash.0));
// Grab the preimage, if it exists, instead of cloning
htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
}
}
- if let Some((feerate, update_state)) = self.pending_update_fee {
+ if let Some((feerate, update_state)) = self.context.pending_update_fee {
if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {
debug_assert!(!self.is_outbound());
log_trace!(logger, " ...promoting inbound AwaitingRemoteRevokeToAnnounce fee update {} to Committed", feerate);
- self.feerate_per_kw = feerate;
- self.pending_update_fee = None;
+ self.context.feerate_per_kw = feerate;
+ self.context.pending_update_fee = None;
}
}
- self.resend_order = RAACommitmentOrder::RevokeAndACKFirst;
+ self.context.resend_order = RAACommitmentOrder::RevokeAndACKFirst;
let (counterparty_commitment_txid, mut htlcs_ref) = self.build_commitment_no_state_update(logger);
let htlcs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)> =
htlcs_ref.drain(..).map(|(htlc, htlc_source)| (htlc, htlc_source.map(|source_ref| Box::new(source_ref.clone())))).collect();
- if self.announcement_sigs_state == AnnouncementSigsState::MessageSent {
- self.announcement_sigs_state = AnnouncementSigsState::Committed;
+ if self.context.announcement_sigs_state == AnnouncementSigsState::MessageSent {
+ self.context.announcement_sigs_state = AnnouncementSigsState::Committed;
}
- self.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::LatestCounterpartyCommitmentTXInfo {
commitment_txid: counterparty_commitment_txid,
htlc_outputs: htlcs.clone(),
- commitment_number: self.cur_counterparty_commitment_transaction_number,
- their_per_commitment_point: self.counterparty_cur_commitment_point.unwrap()
+ commitment_number: self.context.cur_counterparty_commitment_transaction_number,
+ their_per_commitment_point: self.context.counterparty_cur_commitment_point.unwrap()
}]
};
- self.channel_state |= ChannelState::AwaitingRemoteRevoke as u32;
+ self.context.channel_state |= ChannelState::AwaitingRemoteRevoke as u32;
monitor_update
}
fn build_commitment_no_state_update<L: Deref>(&self, logger: &L) -> (Txid, Vec<(HTLCOutputInCommitment, Option<&HTLCSource>)>) where L::Target: Logger {
let counterparty_keys = self.build_remote_transaction_keys();
- let commitment_stats = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
+ let commitment_stats = self.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
#[cfg(any(test, fuzzing))]
{
if !self.is_outbound() {
- let projected_commit_tx_info = self.next_remote_commitment_tx_fee_info_cached.lock().unwrap().take();
- *self.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
+ let projected_commit_tx_info = self.context.next_remote_commitment_tx_fee_info_cached.lock().unwrap().take();
+ *self.context.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
if let Some(info) = projected_commit_tx_info {
- let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len();
+ let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
if info.total_pending_htlcs == total_pending_htlcs
- && info.next_holder_htlc_id == self.next_holder_htlc_id
- && info.next_counterparty_htlc_id == self.next_counterparty_htlc_id
- && info.feerate == self.feerate_per_kw {
- let actual_fee = Self::commit_tx_fee_msat(self.feerate_per_kw, commitment_stats.num_nondust_htlcs, self.opt_anchors());
+ && info.next_holder_htlc_id == self.context.next_holder_htlc_id
+ && info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
+ && info.feerate == self.context.feerate_per_kw {
+ let actual_fee = Self::commit_tx_fee_msat(self.context.feerate_per_kw, commitment_stats.num_nondust_htlcs, self.opt_anchors());
assert_eq!(actual_fee, info.fee);
}
}
self.build_commitment_no_state_update(logger);
let counterparty_keys = self.build_remote_transaction_keys();
- let commitment_stats = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
+ let commitment_stats = self.build_commitment_transaction(self.context.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, true, logger);
let counterparty_commitment_txid = commitment_stats.tx.trust().txid();
let (signature, htlc_signatures);
htlcs.push(htlc);
}
- let res = self.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.secp_ctx)
+ let res = self.context.holder_signer.sign_counterparty_commitment(&commitment_stats.tx, commitment_stats.preimages, &self.context.secp_ctx)
.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?;
signature = res.0;
htlc_signatures = res.1;
}
Ok((msgs::CommitmentSigned {
- channel_id: self.channel_id,
+ channel_id: self.context.channel_id,
signature,
htlc_signatures,
#[cfg(taproot)]
/// Get forwarding information for the counterparty.
pub fn counterparty_forwarding_info(&self) -> Option<CounterpartyForwardingInfo> {
- self.counterparty_forwarding_info.clone()
+ self.context.counterparty_forwarding_info.clone()
}
pub fn channel_update(&mut self, msg: &msgs::ChannelUpdate) -> Result<(), ChannelError> {
- if msg.contents.htlc_minimum_msat >= self.channel_value_satoshis * 1000 {
+ if msg.contents.htlc_minimum_msat >= self.context.channel_value_satoshis * 1000 {
return Err(ChannelError::Close("Minimum htlc value is greater than channel value".to_string()));
}
- self.counterparty_forwarding_info = Some(CounterpartyForwardingInfo {
+ self.context.counterparty_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
target_feerate_sats_per_kw: Option<u32>, override_shutdown_script: Option<ShutdownScript>)
-> Result<(msgs::Shutdown, Option<&ChannelMonitorUpdate>, Vec<(HTLCSource, PaymentHash)>), APIError>
where SP::Target: SignerProvider {
- for htlc in self.pending_outbound_htlcs.iter() {
+ 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.channel_state & BOTH_SIDES_SHUTDOWN_MASK != 0 {
- if (self.channel_state & ChannelState::LocalShutdownSent as u32) == ChannelState::LocalShutdownSent as u32 {
+ if self.context.channel_state & BOTH_SIDES_SHUTDOWN_MASK != 0 {
+ if (self.context.channel_state & ChannelState::LocalShutdownSent as u32) == ChannelState::LocalShutdownSent as u32 {
return Err(APIError::APIMisuseError{err: "Shutdown already in progress".to_owned()});
}
- else if (self.channel_state & ChannelState::RemoteShutdownSent as u32) == ChannelState::RemoteShutdownSent as u32 {
+ else if (self.context.channel_state & ChannelState::RemoteShutdownSent as u32) == ChannelState::RemoteShutdownSent as u32 {
return Err(APIError::ChannelUnavailable{err: "Shutdown already in progress by remote".to_owned()});
}
}
- if self.shutdown_scriptpubkey.is_some() && override_shutdown_script.is_some() {
+ 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_eq!(self.channel_state & ChannelState::ShutdownComplete as u32, 0);
- if self.channel_state & (ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0 {
+ assert_eq!(self.context.channel_state & ChannelState::ShutdownComplete as u32, 0);
+ if self.context.channel_state & (ChannelState::PeerDisconnected as u32 | ChannelState::MonitorUpdateInProgress as u32) != 0 {
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()});
}
// If we haven't funded the channel yet, we don't need to bother ensuring the shutdown
// script is set, we just force-close and call it a day.
let mut chan_closed = false;
- if self.channel_state < ChannelState::FundingSent as u32 {
+ if self.context.channel_state < ChannelState::FundingSent as u32 {
chan_closed = true;
}
- let update_shutdown_script = match self.shutdown_scriptpubkey {
+ let update_shutdown_script = match self.context.shutdown_scriptpubkey {
Some(_) => false,
None if !chan_closed => {
// use override shutdown script if provided
if !shutdown_scriptpubkey.is_compatible(their_features) {
return Err(APIError::IncompatibleShutdownScript { script: shutdown_scriptpubkey.clone() });
}
- self.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
+ self.context.shutdown_scriptpubkey = Some(shutdown_scriptpubkey);
true
},
None => false,
};
// From here on out, we may not fail!
- self.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
- if self.channel_state < ChannelState::FundingSent as u32 {
- self.channel_state = ChannelState::ShutdownComplete as u32;
+ self.context.target_closing_feerate_sats_per_kw = target_feerate_sats_per_kw;
+ if self.context.channel_state < ChannelState::FundingSent as u32 {
+ self.context.channel_state = ChannelState::ShutdownComplete as u32;
} else {
- self.channel_state |= ChannelState::LocalShutdownSent as u32;
+ self.context.channel_state |= ChannelState::LocalShutdownSent as u32;
}
- self.update_time_counter += 1;
+ self.context.update_time_counter += 1;
let monitor_update = if update_shutdown_script {
- self.latest_monitor_update_id += 1;
+ self.context.latest_monitor_update_id += 1;
let monitor_update = ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::ShutdownScript {
scriptpubkey: self.get_closing_scriptpubkey(),
}],
};
self.monitor_updating_paused(false, false, false, Vec::new(), Vec::new(), Vec::new());
if self.push_blockable_mon_update(monitor_update) {
- self.pending_monitor_updates.last().map(|upd| &upd.update)
+ self.context.pending_monitor_updates.last().map(|upd| &upd.update)
} else { None }
} else { None };
let shutdown = msgs::Shutdown {
- channel_id: self.channel_id,
+ 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.holding_cell_update_fee = None;
- let mut dropped_outbound_htlcs = Vec::with_capacity(self.holding_cell_htlc_updates.len());
- self.holding_cell_htlc_updates.retain(|htlc_update| {
+ 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()));
// 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!(self.channel_state != ChannelState::ShutdownComplete as u32);
+ assert!(self.context.channel_state != ChannelState::ShutdownComplete as u32);
// 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 mut dropped_outbound_htlcs = Vec::with_capacity(self.context.holding_cell_htlc_updates.len());
let counterparty_node_id = self.get_counterparty_node_id();
- for htlc_update in self.holding_cell_htlc_updates.drain(..) {
+ for htlc_update in self.context.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));
+ dropped_outbound_htlcs.push((source, payment_hash, counterparty_node_id, self.context.channel_id));
},
_ => {}
}
// funding transaction, don't return a funding txo (which prevents providing the
// monitor update to the user, even if we return one).
// See test_duplicate_chan_id and test_pre_lockin_no_chan_closed_update for more.
- if self.channel_state & (ChannelState::FundingSent as u32 | ChannelState::ChannelReady as u32 | ChannelState::ShutdownComplete as u32) != 0 {
- self.latest_monitor_update_id = CLOSED_CHANNEL_UPDATE_ID;
+ if self.context.channel_state & (ChannelState::FundingSent as u32 | ChannelState::ChannelReady as u32 | ChannelState::ShutdownComplete as u32) != 0 {
+ self.context.latest_monitor_update_id = CLOSED_CHANNEL_UPDATE_ID;
Some((self.get_counterparty_node_id(), funding_txo, ChannelMonitorUpdate {
- update_id: self.latest_monitor_update_id,
+ update_id: self.context.latest_monitor_update_id,
updates: vec![ChannelMonitorUpdateStep::ChannelForceClosed { should_broadcast }],
}))
} else { None }
} else { None };
- self.channel_state = ChannelState::ShutdownComplete as u32;
- self.update_time_counter += 1;
+ self.context.channel_state = ChannelState::ShutdownComplete as u32;
+ self.context.update_time_counter += 1;
(monitor_update, dropped_outbound_htlcs)
}
pub fn inflight_htlc_sources(&self) -> impl Iterator<Item=(&HTLCSource, &PaymentHash)> {
- self.holding_cell_htlc_updates.iter()
+ self.context.holding_cell_htlc_updates.iter()
.flat_map(|htlc_update| {
match htlc_update {
HTLCUpdateAwaitingACK::AddHTLC { source, payment_hash, .. }
_ => None,
}
})
- .chain(self.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
+ .chain(self.context.pending_outbound_htlcs.iter().map(|htlc| (&htlc.source, &htlc.payment_hash)))
}
}
// `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.user_id as u64;
+ 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
// `minimum_depth` we simply write dummy values here.
writer.write_all(&[0; 8])?;
- self.channel_id.write(writer)?;
- (self.channel_state | ChannelState::PeerDisconnected as u32).write(writer)?;
- self.channel_value_satoshis.write(writer)?;
+ self.context.channel_id.write(writer)?;
+ (self.context.channel_state | ChannelState::PeerDisconnected as u32).write(writer)?;
+ self.context.channel_value_satoshis.write(writer)?;
- self.latest_monitor_update_id.write(writer)?;
+ self.context.latest_monitor_update_id.write(writer)?;
let mut key_data = VecWriter(Vec::new());
- self.holder_signer.write(&mut key_data)?;
+ self.context.holder_signer.write(&mut key_data)?;
assert!(key_data.0.len() < core::usize::MAX);
assert!(key_data.0.len() < core::u32::MAX as usize);
(key_data.0.len() as u32).write(writer)?;
// Write out the old serialization for shutdown_pubkey for backwards compatibility, if
// deserialized from that format.
- match self.shutdown_scriptpubkey.as_ref().and_then(|script| script.as_legacy_pubkey()) {
+ match self.context.shutdown_scriptpubkey.as_ref().and_then(|script| script.as_legacy_pubkey()) {
Some(shutdown_pubkey) => shutdown_pubkey.write(writer)?,
None => [0u8; PUBLIC_KEY_SIZE].write(writer)?,
}
- self.destination_script.write(writer)?;
+ self.context.destination_script.write(writer)?;
- self.cur_holder_commitment_transaction_number.write(writer)?;
- self.cur_counterparty_commitment_transaction_number.write(writer)?;
- self.value_to_self_msat.write(writer)?;
+ self.context.cur_holder_commitment_transaction_number.write(writer)?;
+ self.context.cur_counterparty_commitment_transaction_number.write(writer)?;
+ self.context.value_to_self_msat.write(writer)?;
let mut dropped_inbound_htlcs = 0;
- for htlc in self.pending_inbound_htlcs.iter() {
+ for htlc in self.context.pending_inbound_htlcs.iter() {
if let InboundHTLCState::RemoteAnnounced(_) = htlc.state {
dropped_inbound_htlcs += 1;
}
}
- (self.pending_inbound_htlcs.len() as u64 - dropped_inbound_htlcs).write(writer)?;
- for htlc in self.pending_inbound_htlcs.iter() {
+ (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
}
let mut preimages: Vec<&Option<PaymentPreimage>> = vec![];
- (self.pending_outbound_htlcs.len() as u64).write(writer)?;
- for htlc in self.pending_outbound_htlcs.iter() {
+ (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)?;
}
}
- (self.holding_cell_htlc_updates.len() as u64).write(writer)?;
- for update in self.holding_cell_htlc_updates.iter() {
+ (self.context.holding_cell_htlc_updates.len() 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 } => {
0u8.write(writer)?;
}
}
- match self.resend_order {
+ match self.context.resend_order {
RAACommitmentOrder::CommitmentFirst => 0u8.write(writer)?,
RAACommitmentOrder::RevokeAndACKFirst => 1u8.write(writer)?,
}
- self.monitor_pending_channel_ready.write(writer)?;
- self.monitor_pending_revoke_and_ack.write(writer)?;
- self.monitor_pending_commitment_signed.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.monitor_pending_forwards.len() as u64).write(writer)?;
- for &(ref pending_forward, ref htlc_id) in self.monitor_pending_forwards.iter() {
+ (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.monitor_pending_failures.len() as u64).write(writer)?;
- for &(ref htlc_source, ref payment_hash, ref fail_reason) in self.monitor_pending_failures.iter() {
+ (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.is_outbound() {
- self.pending_update_fee.map(|(a, _)| a).write(writer)?;
- } else if let Some((feerate, FeeUpdateState::AwaitingRemoteRevokeToAnnounce)) = self.pending_update_fee {
+ 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.holding_cell_update_fee.write(writer)?;
+ self.context.holding_cell_update_fee.write(writer)?;
- self.next_holder_htlc_id.write(writer)?;
- (self.next_counterparty_htlc_id - dropped_inbound_htlcs).write(writer)?;
- self.update_time_counter.write(writer)?;
- self.feerate_per_kw.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
// consider the stale state on reload.
0u8.write(writer)?;
- self.funding_tx_confirmed_in.write(writer)?;
- self.funding_tx_confirmation_height.write(writer)?;
- self.short_channel_id.write(writer)?;
+ self.context.funding_tx_confirmed_in.write(writer)?;
+ self.context.funding_tx_confirmation_height.write(writer)?;
+ self.context.short_channel_id.write(writer)?;
- self.counterparty_dust_limit_satoshis.write(writer)?;
- self.holder_dust_limit_satoshis.write(writer)?;
- self.counterparty_max_htlc_value_in_flight_msat.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.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;
+ self.context.counterparty_selected_channel_reserve_satoshis.unwrap_or(0).write(writer)?;
- self.counterparty_htlc_minimum_msat.write(writer)?;
- self.holder_htlc_minimum_msat.write(writer)?;
- self.counterparty_max_accepted_htlcs.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.minimum_depth.unwrap_or(0).write(writer)?;
+ self.context.minimum_depth.unwrap_or(0).write(writer)?;
- match &self.counterparty_forwarding_info {
+ match &self.context.counterparty_forwarding_info {
Some(info) => {
1u8.write(writer)?;
info.fee_base_msat.write(writer)?;
None => 0u8.write(writer)?
}
- self.channel_transaction_parameters.write(writer)?;
- self.funding_transaction.write(writer)?;
+ self.context.channel_transaction_parameters.write(writer)?;
+ self.context.funding_transaction.write(writer)?;
- self.counterparty_cur_commitment_point.write(writer)?;
- self.counterparty_prev_commitment_point.write(writer)?;
- self.counterparty_node_id.write(writer)?;
+ self.context.counterparty_cur_commitment_point.write(writer)?;
+ self.context.counterparty_prev_commitment_point.write(writer)?;
+ self.context.counterparty_node_id.write(writer)?;
- self.counterparty_shutdown_scriptpubkey.write(writer)?;
+ self.context.counterparty_shutdown_scriptpubkey.write(writer)?;
- self.commitment_secrets.write(writer)?;
+ self.context.commitment_secrets.write(writer)?;
- self.channel_update_status.write(writer)?;
+ self.context.channel_update_status.write(writer)?;
#[cfg(any(test, fuzzing))]
- (self.historical_inbound_htlc_fulfills.len() as u64).write(writer)?;
+ (self.context.historical_inbound_htlc_fulfills.len() as u64).write(writer)?;
#[cfg(any(test, fuzzing))]
- for htlc in self.historical_inbound_htlc_fulfills.iter() {
+ for htlc in self.context.historical_inbound_htlc_fulfills.iter() {
htlc.write(writer)?;
}
// 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.channel_type != ChannelTypeFeatures::only_static_remote_key() {
- Some(&self.channel_type) } else { None };
+ let chan_type = if self.context.channel_type != ChannelTypeFeatures::only_static_remote_key() {
+ Some(&self.context.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 serialized_holder_selected_reserve =
- if self.holder_selected_channel_reserve_satoshis != Self::get_legacy_default_holder_selected_channel_reserve_satoshis(self.channel_value_satoshis)
- { Some(self.holder_selected_channel_reserve_satoshis) } else { None };
+ if self.context.holder_selected_channel_reserve_satoshis != Self::get_legacy_default_holder_selected_channel_reserve_satoshis(self.context.channel_value_satoshis)
+ { Some(self.context.holder_selected_channel_reserve_satoshis) } else { None };
let mut old_max_in_flight_percent_config = UserConfig::default().channel_handshake_config;
old_max_in_flight_percent_config.max_inbound_htlc_value_in_flight_percent_of_channel = MAX_IN_FLIGHT_PERCENT_LEGACY;
let serialized_holder_htlc_max_in_flight =
- if self.holder_max_htlc_value_in_flight_msat != Self::get_holder_max_htlc_value_in_flight_msat(self.channel_value_satoshis, &old_max_in_flight_percent_config)
- { Some(self.holder_max_htlc_value_in_flight_msat) } else { None };
+ if self.context.holder_max_htlc_value_in_flight_msat != Self::get_holder_max_htlc_value_in_flight_msat(self.context.channel_value_satoshis, &old_max_in_flight_percent_config)
+ { Some(self.context.holder_max_htlc_value_in_flight_msat) } else { None };
- let channel_pending_event_emitted = Some(self.channel_pending_event_emitted);
- let channel_ready_event_emitted = Some(self.channel_ready_event_emitted);
+ let channel_pending_event_emitted = Some(self.context.channel_pending_event_emitted);
+ let channel_ready_event_emitted = Some(self.context.channel_ready_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.user_id >> 64) as u64);
+ let user_id_high_opt = Some((self.context.user_id >> 64) as u64);
- let holder_max_accepted_htlcs = if self.holder_max_accepted_htlcs == DEFAULT_MAX_HTLCS { None } else { Some(self.holder_max_accepted_htlcs) };
+ let holder_max_accepted_htlcs = if self.context.holder_max_accepted_htlcs == DEFAULT_MAX_HTLCS { None } else { Some(self.context.holder_max_accepted_htlcs) };
write_tlv_fields!(writer, {
- (0, self.announcement_sigs, option),
+ (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.minimum_depth, option),
+ (1, self.context.minimum_depth, option),
(2, chan_type, option),
- (3, self.counterparty_selected_channel_reserve_satoshis, option),
+ (3, self.context.counterparty_selected_channel_reserve_satoshis, option),
(4, serialized_holder_selected_reserve, option),
- (5, self.config, required),
+ (5, self.context.config, required),
(6, serialized_holder_htlc_max_in_flight, option),
- (7, self.shutdown_scriptpubkey, option),
- (9, self.target_closing_feerate_sats_per_kw, option),
- (11, self.monitor_pending_finalized_fulfills, vec_type),
- (13, self.channel_creation_height, required),
+ (7, self.context.shutdown_scriptpubkey, option),
+ (9, self.context.target_closing_feerate_sats_per_kw, option),
+ (11, self.context.monitor_pending_finalized_fulfills, vec_type),
+ (13, self.context.channel_creation_height, required),
(15, preimages, vec_type),
- (17, self.announcement_sigs_state, required),
- (19, self.latest_inbound_scid_alias, option),
- (21, self.outbound_scid_alias, required),
+ (17, self.context.announcement_sigs_state, required),
+ (19, self.context.latest_inbound_scid_alias, option),
+ (21, self.context.outbound_scid_alias, required),
(23, channel_ready_event_emitted, option),
(25, user_id_high_opt, option),
- (27, self.channel_keys_id, required),
+ (27, self.context.channel_keys_id, required),
(28, holder_max_accepted_htlcs, option),
- (29, self.temporary_channel_id, option),
+ (29, self.context.temporary_channel_id, option),
(31, channel_pending_event_emitted, option),
- (33, self.pending_monitor_updates, vec_type),
+ (33, self.context.pending_monitor_updates, vec_type),
});
Ok(())
let holder_max_accepted_htlcs = holder_max_accepted_htlcs.unwrap_or(DEFAULT_MAX_HTLCS);
Ok(Channel {
- user_id,
+ context: ChannelContext {
+ user_id,
- config: config.unwrap(),
+ config: config.unwrap(),
- prev_config: None,
+ 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,
+ // 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: announcement_sigs_state.unwrap(),
- secp_ctx,
- channel_value_satoshis,
-
- latest_monitor_update_id,
-
- holder_signer,
- shutdown_scriptpubkey,
- destination_script,
-
- cur_holder_commitment_transaction_number,
- cur_counterparty_commitment_transaction_number,
- value_to_self_msat,
-
- holder_max_accepted_htlcs,
- pending_inbound_htlcs,
- pending_outbound_htlcs,
- holding_cell_htlc_updates,
-
- resend_order,
-
- 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(),
-
- pending_update_fee,
- holding_cell_update_fee,
- next_holder_htlc_id,
- next_counterparty_htlc_id,
- update_time_counter,
- feerate_per_kw,
+ channel_id,
+ temporary_channel_id,
+ channel_state,
+ announcement_sigs_state: announcement_sigs_state.unwrap(),
+ secp_ctx,
+ channel_value_satoshis,
- #[cfg(debug_assertions)]
- holder_max_commitment_tx_output: Mutex::new((0, 0)),
- #[cfg(debug_assertions)]
- counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
+ latest_monitor_update_id,
- last_sent_closing_fee: None,
- pending_counterparty_closing_signed: None,
- closing_fee_limits: None,
- target_closing_feerate_sats_per_kw,
+ holder_signer,
+ shutdown_scriptpubkey,
+ destination_script,
- inbound_awaiting_accept: false,
+ cur_holder_commitment_transaction_number,
+ cur_counterparty_commitment_transaction_number,
+ value_to_self_msat,
- funding_tx_confirmed_in,
- funding_tx_confirmation_height,
- short_channel_id,
- channel_creation_height: channel_creation_height.unwrap(),
+ holder_max_accepted_htlcs,
+ pending_inbound_htlcs,
+ pending_outbound_htlcs,
+ holding_cell_htlc_updates,
- 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_selected_channel_reserve_satoshis,
- holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.unwrap(),
- counterparty_htlc_minimum_msat,
- holder_htlc_minimum_msat,
- counterparty_max_accepted_htlcs,
- minimum_depth,
+ resend_order,
- counterparty_forwarding_info,
+ 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(),
- channel_transaction_parameters: channel_parameters,
- funding_transaction,
+ pending_update_fee,
+ holding_cell_update_fee,
+ next_holder_htlc_id,
+ next_counterparty_htlc_id,
+ update_time_counter,
+ feerate_per_kw,
- counterparty_cur_commitment_point,
- counterparty_prev_commitment_point,
- counterparty_node_id,
+ #[cfg(debug_assertions)]
+ holder_max_commitment_tx_output: Mutex::new((0, 0)),
+ #[cfg(debug_assertions)]
+ counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
- counterparty_shutdown_scriptpubkey,
+ last_sent_closing_fee: None,
+ pending_counterparty_closing_signed: None,
+ closing_fee_limits: None,
+ target_closing_feerate_sats_per_kw,
- commitment_secrets,
+ inbound_awaiting_accept: false,
- channel_update_status,
- closing_signed_in_flight: false,
+ funding_tx_confirmed_in,
+ funding_tx_confirmation_height,
+ short_channel_id,
+ channel_creation_height: channel_creation_height.unwrap(),
- announcement_sigs,
+ 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_selected_channel_reserve_satoshis,
+ holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.unwrap(),
+ counterparty_htlc_minimum_msat,
+ holder_htlc_minimum_msat,
+ counterparty_max_accepted_htlcs,
+ minimum_depth,
- #[cfg(any(test, fuzzing))]
- next_local_commitment_tx_fee_info_cached: Mutex::new(None),
- #[cfg(any(test, fuzzing))]
- next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
+ counterparty_forwarding_info,
- workaround_lnd_bug_4006: None,
- sent_message_awaiting_response: None,
+ channel_transaction_parameters: channel_parameters,
+ funding_transaction,
- latest_inbound_scid_alias,
- // Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
- outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
+ counterparty_cur_commitment_point,
+ counterparty_prev_commitment_point,
+ counterparty_node_id,
- channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
- channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
+ counterparty_shutdown_scriptpubkey,
- #[cfg(any(test, fuzzing))]
- historical_inbound_htlc_fulfills,
+ commitment_secrets,
+
+ channel_update_status,
+ closing_signed_in_flight: false,
+
+ announcement_sigs,
+
+ #[cfg(any(test, fuzzing))]
+ next_local_commitment_tx_fee_info_cached: Mutex::new(None),
+ #[cfg(any(test, fuzzing))]
+ next_remote_commitment_tx_fee_info_cached: Mutex::new(None),
- channel_type: channel_type.unwrap(),
- channel_keys_id,
+ workaround_lnd_bug_4006: None,
+ sent_message_awaiting_response: None,
- pending_monitor_updates: pending_monitor_updates.unwrap(),
+ latest_inbound_scid_alias,
+ // Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
+ outbound_scid_alias: outbound_scid_alias.unwrap_or(0),
+
+ channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),
+ channel_ready_event_emitted: channel_ready_event_emitted.unwrap_or(true),
+
+ #[cfg(any(test, fuzzing))]
+ historical_inbound_htlc_fulfills,
+
+ channel_type: channel_type.unwrap(),
+ channel_keys_id,
+
+ pending_monitor_updates: pending_monitor_updates.unwrap(),
+ }
})
}
}
let mut accept_channel_msg = node_b_chan.accept_inbound_channel(0);
accept_channel_msg.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.holder_dust_limit_satoshis = 1560;
+ node_a_chan.context.holder_dust_limit_satoshis = 1560;
// 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.pending_inbound_htlcs.push(InboundHTLCOutput {
+ node_a_chan.context.pending_inbound_htlcs.push(InboundHTLCOutput {
htlc_id: 0,
amount_msat: htlc_amount_msat,
payment_hash: PaymentHash(Sha256::hash(&[42; 32]).into_inner()),
state: InboundHTLCState::Committed,
});
- node_a_chan.pending_outbound_htlcs.push(OutboundHTLCOutput {
+ 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]).into_inner()),
// the dust limit check.
let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
let local_commit_tx_fee = node_a_chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
- let local_commit_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.feerate_per_kw, 0, node_a_chan.opt_anchors());
+ let local_commit_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.context.feerate_per_kw, 0, node_a_chan.opt_anchors());
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.channel_transaction_parameters.is_outbound_from_holder = false;
- let remote_commit_fee_3_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.feerate_per_kw, 3, node_a_chan.opt_anchors());
+ node_a_chan.context.channel_transaction_parameters.is_outbound_from_holder = false;
+ let remote_commit_fee_3_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(node_a_chan.context.feerate_per_kw, 3, node_a_chan.opt_anchors());
let htlc_candidate = HTLCCandidate::new(htlc_amount_msat, HTLCInitiator::LocalOffered);
let remote_commit_tx_fee = node_a_chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
assert_eq!(remote_commit_tx_fee, remote_commit_fee_3_htlcs);
let config = UserConfig::default();
let mut chan = Channel::<EnforcingSigner>::new_outbound(&fee_est, &&keys_provider, &&keys_provider, node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
- let commitment_tx_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.feerate_per_kw, 0, chan.opt_anchors());
- let commitment_tx_fee_1_htlc = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.feerate_per_kw, 1, chan.opt_anchors());
+ let commitment_tx_fee_0_htlcs = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.context.feerate_per_kw, 0, chan.opt_anchors());
+ let commitment_tx_fee_1_htlc = Channel::<EnforcingSigner>::commit_tx_fee_msat(chan.context.feerate_per_kw, 1, chan.opt_anchors());
// 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 = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.holder_dust_limit_satoshis + 1) * 1000;
+ let htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.context.holder_dust_limit_satoshis + 1) * 1000;
let htlc_candidate = HTLCCandidate::new(htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
let commitment_tx_fee = chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
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 = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.holder_dust_limit_satoshis - 1) * 1000;
+ let dust_htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.context.holder_dust_limit_satoshis - 1) * 1000;
let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_below_success, HTLCInitiator::RemoteOffered);
let commitment_tx_fee = chan.next_local_commit_tx_fee_msat(htlc_candidate, None);
assert_eq!(commitment_tx_fee, commitment_tx_fee_0_htlcs);
- chan.channel_transaction_parameters.is_outbound_from_holder = false;
+ chan.context.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 = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.counterparty_dust_limit_satoshis + 1) * 1000;
+ let dust_htlc_amt_above_timeout = ((253 * htlc_timeout_tx_weight(chan.opt_anchors()) / 1000) + chan.context.counterparty_dust_limit_satoshis + 1) * 1000;
let htlc_candidate = HTLCCandidate::new(dust_htlc_amt_above_timeout, HTLCInitiator::LocalOffered);
let commitment_tx_fee = chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
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 = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.counterparty_dust_limit_satoshis - 1) * 1000;
+ let htlc_amt_below_success = ((253 * htlc_success_tx_weight(chan.opt_anchors()) / 1000) + chan.context.counterparty_dust_limit_satoshis - 1) * 1000;
let htlc_candidate = HTLCCandidate::new(htlc_amt_below_success, HTLCInitiator::RemoteOffered);
let commitment_tx_fee = chan.next_remote_commit_tx_fee_msat(htlc_candidate, None);
assert_eq!(commitment_tx_fee, commitment_tx_fee_1_htlc);
// `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_1 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_2_percent), 10000000, 100000, 42, &config_2_percent, 0, 42).unwrap();
- let chan_1_value_msat = chan_1.channel_value_satoshis * 1000;
- assert_eq!(chan_1.holder_max_htlc_value_in_flight_msat, (chan_1_value_msat as f64 * 0.02) as u64);
+ let chan_1_value_msat = chan_1.context.channel_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 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_99_percent), 10000000, 100000, 42, &config_99_percent, 0, 42).unwrap();
- let chan_2_value_msat = chan_2.channel_value_satoshis * 1000;
- assert_eq!(chan_2.holder_max_htlc_value_in_flight_msat, (chan_2_value_msat as f64 * 0.99) as u64);
+ let chan_2_value_msat = chan_2.context.channel_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(genesis_block(network).header.block_hash());
// `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 = Channel::<EnforcingSigner>::new_from_req(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_2_percent), &channelmanager::provided_init_features(&config_2_percent), &chan_1_open_channel_msg, 7, &config_2_percent, 0, &&logger, 42).unwrap();
- let chan_3_value_msat = chan_3.channel_value_satoshis * 1000;
- assert_eq!(chan_3.holder_max_htlc_value_in_flight_msat, (chan_3_value_msat as f64 * 0.02) as u64);
+ let chan_3_value_msat = chan_3.context.channel_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 = Channel::<EnforcingSigner>::new_from_req(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_99_percent), &channelmanager::provided_init_features(&config_99_percent), &chan_1_open_channel_msg, 7, &config_99_percent, 0, &&logger, 42).unwrap();
- let chan_4_value_msat = chan_4.channel_value_satoshis * 1000;
- assert_eq!(chan_4.holder_max_htlc_value_in_flight_msat, (chan_4_value_msat as f64 * 0.99) as u64);
+ let chan_4_value_msat = chan_4.context.channel_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 `new_outbound` uses the lower bound of the configurable percentage values (1%)
// if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
let chan_5 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_0_percent), 10000000, 100000, 42, &config_0_percent, 0, 42).unwrap();
- let chan_5_value_msat = chan_5.channel_value_satoshis * 1000;
- assert_eq!(chan_5.holder_max_htlc_value_in_flight_msat, (chan_5_value_msat as f64 * 0.01) as u64);
+ let chan_5_value_msat = chan_5.context.channel_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 `new_outbound` uses the upper bound of the configurable percentage values
// (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
// than 100.
let chan_6 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&config_101_percent), 10000000, 100000, 42, &config_101_percent, 0, 42).unwrap();
- let chan_6_value_msat = chan_6.channel_value_satoshis * 1000;
- assert_eq!(chan_6.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
+ let chan_6_value_msat = chan_6.context.channel_value_satoshis * 1000;
+ assert_eq!(chan_6.context.holder_max_htlc_value_in_flight_msat, chan_6_value_msat);
// Test that `new_from_req` uses the lower bound of the configurable percentage values (1%)
// if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a value less than 1.
let chan_7 = Channel::<EnforcingSigner>::new_from_req(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_0_percent), &channelmanager::provided_init_features(&config_0_percent), &chan_1_open_channel_msg, 7, &config_0_percent, 0, &&logger, 42).unwrap();
- let chan_7_value_msat = chan_7.channel_value_satoshis * 1000;
- assert_eq!(chan_7.holder_max_htlc_value_in_flight_msat, (chan_7_value_msat as f64 * 0.01) as u64);
+ let chan_7_value_msat = chan_7.context.channel_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 `new_from_req` uses the upper bound of the configurable percentage values
// (100%) if `max_inbound_htlc_value_in_flight_percent_of_channel` is set to a larger value
// than 100.
let chan_8 = Channel::<EnforcingSigner>::new_from_req(&feeest, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&config_101_percent), &channelmanager::provided_init_features(&config_101_percent), &chan_1_open_channel_msg, 7, &config_101_percent, 0, &&logger, 42).unwrap();
- let chan_8_value_msat = chan_8.channel_value_satoshis * 1000;
- assert_eq!(chan_8.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
+ let chan_8_value_msat = chan_8.context.channel_value_satoshis * 1000;
+ assert_eq!(chan_8.context.holder_max_htlc_value_in_flight_msat, chan_8_value_msat);
}
#[test]
outbound_node_config.channel_handshake_config.their_channel_reserve_proportional_millionths = (outbound_selected_channel_reserve_perc * 1_000_000.0) as u32;
let chan = Channel::<EnforcingSigner>::new_outbound(&&fee_est, &&keys_provider, &&keys_provider, outbound_node_id, &channelmanager::provided_init_features(&outbound_node_config), channel_value_satoshis, 100_000, 42, &outbound_node_config, 0, 42).unwrap();
- let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64);
- assert_eq!(chan.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
+ let expected_outbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * outbound_selected_channel_reserve_perc) as u64);
+ assert_eq!(chan.context.holder_selected_channel_reserve_satoshis, expected_outbound_selected_chan_reserve);
let chan_open_channel_msg = chan.get_open_channel(genesis_block(network).header.block_hash());
let mut inbound_node_config = UserConfig::default();
if outbound_selected_channel_reserve_perc + inbound_selected_channel_reserve_perc < 1.0 {
let chan_inbound_node = Channel::<EnforcingSigner>::new_from_req(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, 42).unwrap();
- let expected_inbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.channel_value_satoshis as f64 * inbound_selected_channel_reserve_perc) as u64);
+ let expected_inbound_selected_chan_reserve = cmp::max(MIN_THEIR_CHAN_RESERVE_SATOSHIS, (chan.context.channel_value_satoshis as f64 * inbound_selected_channel_reserve_perc) as u64);
- assert_eq!(chan_inbound_node.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
- assert_eq!(chan_inbound_node.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
+ assert_eq!(chan_inbound_node.context.holder_selected_channel_reserve_satoshis, expected_inbound_selected_chan_reserve);
+ assert_eq!(chan_inbound_node.context.counterparty_selected_channel_reserve_satoshis.unwrap(), expected_outbound_selected_chan_reserve);
} else {
// Channel Negotiations failed
let result = Channel::<EnforcingSigner>::new_from_req(&&fee_est, &&keys_provider, &&keys_provider, inbound_node_id, &channelmanager::provided_channel_type_features(&inbound_node_config), &channelmanager::provided_init_features(&outbound_node_config), &chan_open_channel_msg, 7, &inbound_node_config, 0, &&logger, 42);
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 = Channel::<EnforcingSigner>::new_outbound(&feeest, &&keys_provider, &&keys_provider, node_b_node_id, &channelmanager::provided_init_features(&config), 10000000, 100000, 42, &config, 0, 42).unwrap();
- assert!(node_a_chan.counterparty_forwarding_info.is_none());
- assert_eq!(node_a_chan.holder_htlc_minimum_msat, 1); // the default
+ assert!(node_a_chan.context.counterparty_forwarding_info.is_none());
+ assert_eq!(node_a_chan.context.holder_htlc_minimum_msat, 1); // the default
assert!(node_a_chan.counterparty_forwarding_info().is_none());
// Make sure that receiving a channel update will update the Channel as expected.
// 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.holder_htlc_minimum_msat, 1);
+ assert_eq!(node_a_chan.context.holder_htlc_minimum_msat, 1);
match node_a_chan.counterparty_forwarding_info() {
Some(info) => {
assert_eq!(info.cltv_expiry_delta, 100);
let mut config = UserConfig::default();
config.channel_handshake_config.announced_channel = false;
let mut chan = Channel::<InMemorySigner>::new_outbound(&LowerBoundedFeeEstimator::new(&feeest), &&keys_provider, &&keys_provider, counterparty_node_id, &channelmanager::provided_init_features(&config), 10_000_000, 0, 42, &config, 0, 42).unwrap(); // Nothing uses their network key in this test
- chan.holder_dust_limit_satoshis = 546;
- chan.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
+ chan.context.holder_dust_limit_satoshis = 546;
+ chan.context.counterparty_selected_channel_reserve_satoshis = Some(0); // Filled in in accept_channel
let funding_info = OutPoint{ txid: Txid::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), index: 0 };
delayed_payment_basepoint: public_from_secret_hex(&secp_ctx, "1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13"),
htlc_basepoint: public_from_secret_hex(&secp_ctx, "4444444444444444444444444444444444444444444444444444444444444444")
};
- chan.channel_transaction_parameters.counterparty_parameters = Some(
+ chan.context.channel_transaction_parameters.counterparty_parameters = Some(
CounterpartyChannelTransactionParameters {
pubkeys: counterparty_pubkeys.clone(),
selected_contest_delay: 144
});
- chan.channel_transaction_parameters.funding_outpoint = Some(funding_info);
- signer.provide_channel_parameters(&chan.channel_transaction_parameters);
+ chan.context.channel_transaction_parameters.funding_outpoint = Some(funding_info);
+ signer.provide_channel_parameters(&chan.context.channel_transaction_parameters);
assert_eq!(counterparty_pubkeys.payment_point.serialize()[..],
hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]);
// 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 delayed_payment_base = &chan.holder_signer.pubkeys().delayed_payment_basepoint;
+ let delayed_payment_base = &chan.context.holder_signer.pubkeys().delayed_payment_basepoint;
let per_commitment_secret = SecretKey::from_slice(&hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap();
let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret);
- let htlc_basepoint = &chan.holder_signer.pubkeys().htlc_basepoint;
+ let htlc_basepoint = &chan.context.holder_signer.pubkeys().htlc_basepoint;
let keys = TxCreationKeys::derive_new(&secp_ctx, &per_commitment_point, delayed_payment_base, htlc_basepoint, &counterparty_pubkeys.revocation_basepoint, &counterparty_pubkeys.htlc_basepoint);
macro_rules! test_commitment {
( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
- chan.channel_transaction_parameters.opt_anchors = None;
+ chan.context.channel_transaction_parameters.opt_anchors = None;
test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, false, $($remain)*);
};
}
macro_rules! test_commitment_with_anchors {
( $counterparty_sig_hex: expr, $sig_hex: expr, $tx_hex: expr, $($remain:tt)* ) => {
- chan.channel_transaction_parameters.opt_anchors = Some(());
+ chan.context.channel_transaction_parameters.opt_anchors = Some(());
test_commitment_common!($counterparty_sig_hex, $sig_hex, $tx_hex, true, $($remain)*);
};
}
let unsigned_tx = trusted_tx.built_transaction();
let redeemscript = chan.get_funding_redeemscript();
let counterparty_signature = Signature::from_der(&hex::decode($counterparty_sig_hex).unwrap()[..]).unwrap();
- let sighash = unsigned_tx.get_sighash_all(&redeemscript, chan.channel_value_satoshis);
+ let sighash = unsigned_tx.get_sighash_all(&redeemscript, chan.context.channel_value_satoshis);
log_trace!(logger, "unsigned_tx = {}", hex::encode(serialize(&unsigned_tx.transaction)));
assert!(secp_ctx.verify_ecdsa(&sighash, &counterparty_signature, chan.counterparty_funding_pubkey()).is_ok(), "verify counterparty commitment sig");
commitment_tx.clone(),
counterparty_signature,
counterparty_htlc_sigs,
- &chan.holder_signer.pubkeys().funding_pubkey,
+ &chan.context.holder_signer.pubkeys().funding_pubkey,
chan.counterparty_funding_pubkey()
);
let (holder_sig, htlc_sigs) = signer.sign_holder_commitment_and_htlcs(&holder_commitment_tx, &secp_ctx).unwrap();
let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();
let ref htlc = htlcs[$htlc_idx];
- let htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, chan.feerate_per_kw,
+ let htlc_tx = chan_utils::build_htlc_transaction(&unsigned_tx.txid, chan.context.feerate_per_kw,
chan.get_counterparty_selected_contest_delay().unwrap(),
&htlc, $opt_anchors, false, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, $opt_anchors, &keys);
let signature = Signature::from_der(&hex::decode($htlc_sig_hex).unwrap()[..]).unwrap();
assert_eq!(signature, *(htlc_sig.1).1, "htlc sig");
let index = (htlc_sig.1).0;
- let channel_parameters = chan.channel_transaction_parameters.as_holder_broadcastable();
+ let channel_parameters = chan.context.channel_transaction_parameters.as_holder_broadcastable();
let trusted_tx = holder_commitment_tx.trust();
log_trace!(logger, "htlc_tx = {}", hex::encode(serialize(&trusted_tx.get_signed_htlc_tx(&channel_parameters, index, &(htlc_sig.0).1, (htlc_sig.1).1, &preimage))));
assert_eq!(serialize(&trusted_tx.get_signed_htlc_tx(&channel_parameters, index, &(htlc_sig.0).1, (htlc_sig.1).1, &preimage))[..],
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
// simple commitment tx with no HTLCs
- chan.value_to_self_msat = 7000000000;
+ chan.context.value_to_self_msat = 7000000000;
test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
"30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
"30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
- chan.pending_inbound_htlcs.push({
+ chan.context.pending_inbound_htlcs.push({
let mut out = InboundHTLCOutput{
htlc_id: 0,
amount_msat: 1000000,
out.payment_hash.0 = Sha256::hash(&hex::decode("0000000000000000000000000000000000000000000000000000000000000000").unwrap()).into_inner();
out
});
- chan.pending_inbound_htlcs.push({
+ chan.context.pending_inbound_htlcs.push({
let mut out = InboundHTLCOutput{
htlc_id: 1,
amount_msat: 2000000,
out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
out
});
- chan.pending_outbound_htlcs.push({
+ chan.context.pending_outbound_htlcs.push({
let mut out = OutboundHTLCOutput{
htlc_id: 2,
amount_msat: 2000000,
out.payment_hash.0 = Sha256::hash(&hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()).into_inner();
out
});
- chan.pending_outbound_htlcs.push({
+ chan.context.pending_outbound_htlcs.push({
let mut out = OutboundHTLCOutput{
htlc_id: 3,
amount_msat: 3000000,
out.payment_hash.0 = Sha256::hash(&hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()).into_inner();
out
});
- chan.pending_inbound_htlcs.push({
+ chan.context.pending_inbound_htlcs.push({
let mut out = InboundHTLCOutput{
htlc_id: 4,
amount_msat: 4000000,
});
// commitment tx with all five HTLCs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 0;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 0;
test_commitment!("3044022009b048187705a8cbc9ad73adbe5af148c3d012e1f067961486c822c7af08158c022006d66f3704cfab3eb2dc49dae24e4aa22a6910fc9b424007583204e3621af2e5",
"304402206fc2d1f10ea59951eefac0b4b7c396a3c3d87b71ff0b019796ef4535beaf36f902201765b0181e514d04f4c8ad75659d7037be26cdb3f8bb6f78fe61decef484c3ea",
} );
// commitment tx with seven outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 647;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 647;
test_commitment!("3045022100a135f9e8a5ed25f7277446c67956b00ce6f610ead2bdec2c2f686155b7814772022059f1f6e1a8b336a68efcc1af3fe4d422d4827332b5b067501b099c47b7b5b5ee",
"30450221009ec15c687898bb4da8b3a833e5ab8bfc51ec6e9202aaa8e66611edfd4a85ed1102203d7183e45078b9735c93450bc3415d3e5a8c576141a711ec6ddcb4a893926bb7",
} );
// commitment tx with six outputs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 648;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 648;
test_commitment!("304402203948f900a5506b8de36a4d8502f94f21dd84fd9c2314ab427d52feaa7a0a19f2022059b6a37a4adaa2c5419dc8aea63c6e2a2ec4c4bde46207f6dc1fcd22152fc6e5",
"3045022100b15f72908ba3382a34ca5b32519240a22300cc6015b6f9418635fb41f3d01d8802207adb331b9ed1575383dca0f2355e86c173802feecf8298fbea53b9d4610583e9",
} );
// anchors: commitment tx with six outputs untrimmed (minimum dust limit)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 645;
- chan.holder_dust_limit_satoshis = 1001;
+ chan.context.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",
} );
// commitment tx with six outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 2069;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 2069;
+ chan.context.holder_dust_limit_satoshis = 546;
test_commitment!("304502210090b96a2498ce0c0f2fadbec2aab278fed54c1a7838df793ec4d2c78d96ec096202204fdd439c50f90d483baa7b68feeef4bd33bc277695405447bcd0bfb2ca34d7bc",
"3045022100ad9a9bbbb75d506ca3b716b336ee3cf975dd7834fcf129d7dd188146eb58a8b4022061a759ee417339f7fe2ea1e8deb83abb6a74db31a09b7648a932a639cda23e33",
} );
// commitment tx with five outputs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 2070;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 2070;
test_commitment!("304402204ca1ba260dee913d318271d86e10ca0f5883026fb5653155cff600fb40895223022037b145204b7054a40e08bb1fefbd826f827b40838d3e501423bcc57924bcb50c",
"3044022001014419b5ba00e083ac4e0a85f19afc848aacac2d483b4b525d15e2ae5adbfe022015ebddad6ee1e72b47cb09f3e78459da5be01ccccd95dceca0e056a00cc773c1",
} );
// commitment tx with five outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 2194;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 2194;
test_commitment!("304402204bb3d6e279d71d9da414c82de42f1f954267c762b2e2eb8b76bc3be4ea07d4b0022014febc009c5edc8c3fc5d94015de163200f780046f1c293bfed8568f08b70fb3",
"3044022072c2e2b1c899b2242656a537dde2892fa3801be0d6df0a87836c550137acde8302201654aa1974d37a829083c3ba15088689f30b56d6a4f6cb14c7bad0ee3116d398",
} );
// commitment tx with four outputs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 2195;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 2195;
test_commitment!("304402201a8c1b1f9671cd9e46c7323a104d7047cc48d3ee80d40d4512e0c72b8dc65666022066d7f9a2ce18c9eb22d2739ffcce05721c767f9b607622a31b6ea5793ddce403",
"3044022044d592025b610c0d678f65032e87035cdfe89d1598c522cc32524ae8172417c30220749fef9d5b2ae8cdd91ece442ba8809bc891efedae2291e578475f97715d1767",
} );
// anchors: commitment tx with four outputs untrimmed (minimum dust limit)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 2185;
- chan.holder_dust_limit_satoshis = 2001;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 2185;
+ chan.context.holder_dust_limit_satoshis = 2001;
test_commitment_with_anchors!("3044022040f63a16148cf35c8d3d41827f5ae7f7c3746885bb64d4d1b895892a83812b3e02202fcf95c2bf02c466163b3fa3ced6a24926fbb4035095a96842ef516e86ba54c0",
"3045022100cd8479cfe1edb1e5a1d487391e0451a469c7171e51e680183f19eb4321f20e9b02204eab7d5a6384b1b08e03baa6e4d9748dfd2b5ab2bae7e39604a0d0055bbffdd5",
} );
// commitment tx with four outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 3702;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 3702;
+ chan.context.holder_dust_limit_satoshis = 546;
test_commitment!("304502210092a587aeb777f869e7ff0d7898ea619ee26a3dacd1f3672b945eea600be431100220077ee9eae3528d15251f2a52b607b189820e57a6ccfac8d1af502b132ee40169",
"3045022100e5efb73c32d32da2d79702299b6317de6fb24a60476e3855926d78484dd1b3c802203557cb66a42c944ef06e00bcc4da35a5bcb2f185aab0f8e403e519e1d66aaf75",
} );
// commitment tx with three outputs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 3703;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 3703;
test_commitment!("3045022100b495d239772a237ff2cf354b1b11be152fd852704cb184e7356d13f2fb1e5e430220723db5cdb9cbd6ead7bfd3deb419cf41053a932418cbb22a67b581f40bc1f13e",
"304402201b736d1773a124c745586217a75bed5f66c05716fbe8c7db4fdb3c3069741cdd02205083f39c321c1bcadfc8d97e3c791a66273d936abac0c6a2fde2ed46019508e1",
} );
// anchors: commitment tx with three outputs untrimmed (minimum dust limit)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 3687;
- chan.holder_dust_limit_satoshis = 3001;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 3687;
+ chan.context.holder_dust_limit_satoshis = 3001;
test_commitment_with_anchors!("3045022100ad6c71569856b2d7ff42e838b4abe74a713426b37f22fa667a195a4c88908c6902202b37272b02a42dc6d9f4f82cab3eaf84ac882d9ed762859e1e75455c2c228377",
"3045022100c970799bcb33f43179eb43b3378a0a61991cf2923f69b36ef12548c3df0e6d500220413dc27d2e39ee583093adfcb7799be680141738babb31cc7b0669a777a31f5d",
} );
// commitment tx with three outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 4914;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 4914;
+ chan.context.holder_dust_limit_satoshis = 546;
test_commitment!("3045022100b4b16d5f8cc9fc4c1aff48831e832a0d8990e133978a66e302c133550954a44d022073573ce127e2200d316f6b612803a5c0c97b8d20e1e44dbe2ac0dd2fb8c95244",
"3045022100d72638bc6308b88bb6d45861aae83e5b9ff6e10986546e13bce769c70036e2620220320be7c6d66d22f30b9fcd52af66531505b1310ca3b848c19285b38d8a1a8c19",
} );
// commitment tx with two outputs untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 4915;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.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.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 4894;
- chan.holder_dust_limit_satoshis = 4001;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 4894;
+ chan.context.holder_dust_limit_satoshis = 4001;
test_commitment_with_anchors!("3045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b95",
"30450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd",
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994ad0886a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221009f16ac85d232e4eddb3fcd750a68ebf0b58e3356eaada45d3513ede7e817bf4c02207c2b043b4e5f971261975406cb955219fa56bffe5d834a833694b5abc1ce4cfd01483045022100e784a66b1588575801e237d35e510fd92a81ae3a4a2a1b90c031ad803d07b3f3022021bc5f16501f167607d63b681442da193eb0a76b4b7fd25c2ed4f8b28fd35b9501475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
// commitment tx with two outputs untrimmed (maximum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 9651180;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 9651180;
+ chan.context.holder_dust_limit_satoshis = 546;
test_commitment!("304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd3",
"3045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de",
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b800222020000000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80ec0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e4840400483045022100e11b638c05c650c2f63a421d36ef8756c5ce82f2184278643520311cdf50aa200220259565fb9c8e4a87ccaf17f27a3b9ca4f20625754a0920d9c6c239d8156a11de0147304402200a8544eba1d216f5c5e530597665fa9bec56943c0f66d98fc3d028df52d84f7002201e45fa5c6bc3a506cc2553e7d1c0043a9811313fc39c954692c0d47cfce2bbd301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
// commitment tx with one output untrimmed (minimum feerate)
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 9651181;
+ chan.context.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.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 6216010;
- chan.holder_dust_limit_satoshis = 4001;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 6216010;
+ chan.context.holder_dust_limit_satoshis = 4001;
test_commitment_with_anchors!("30450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf",
"30450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1",
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a04004830450221009ad80792e3038fe6968d12ff23e6888a565c3ddd065037f357445f01675d63f3022018384915e5f1f4ae157e15debf4f49b61c8d9d2b073c7d6f97c4a68caa3ed4c1014830450221008fd5dbff02e4b59020d4cd23a3c30d3e287065fda75a0a09b402980adf68ccda022001e0b8b620cd915ddff11f1de32addf23d81d51b90e6841b2cb8dcaf3faa5ecf01475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
// commitment tx with fee greater than funder amount
- chan.value_to_self_msat = 6993000000; // 7000000000 - 7000000
- chan.feerate_per_kw = 9651936;
- chan.holder_dust_limit_satoshis = 546;
+ chan.context.value_to_self_msat = 6993000000; // 7000000000 - 7000000
+ chan.context.feerate_per_kw = 9651936;
+ chan.context.holder_dust_limit_satoshis = 546;
test_commitment!("304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a2",
"304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a379",
"02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b8001c0c62d0000000000160014cc1b07838e387deacd0e5232e1e8b49f4c29e484040047304402207e8d51e0c570a5868a78414f4e0cbfaed1106b171b9581542c30718ee4eb95ba02203af84194c97adf98898c9afe2f2ed4a7f8dba05a2dfab28ac9d9c604aa49a3790147304402202ade0142008309eb376736575ad58d03e5b115499709c6db0b46e36ff394b492022037b63d78d66404d6504d4c4ac13be346f3d1802928a6d3ad95a6a944227161a201475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
// commitment tx with 3 htlc outputs, 2 offered having the same amount and preimage
- chan.value_to_self_msat = 7_000_000_000 - 2_000_000;
- chan.feerate_per_kw = 253;
- chan.pending_inbound_htlcs.clear();
- chan.pending_inbound_htlcs.push({
+ chan.context.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({
let mut out = InboundHTLCOutput{
htlc_id: 1,
amount_msat: 2000000,
out.payment_hash.0 = Sha256::hash(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()).into_inner();
out
});
- chan.pending_outbound_htlcs.clear();
- chan.pending_outbound_htlcs.push({
+ chan.context.pending_outbound_htlcs.clear();
+ chan.context.pending_outbound_htlcs.push({
let mut out = OutboundHTLCOutput{
htlc_id: 6,
amount_msat: 5000001,
out.payment_hash.0 = Sha256::hash(&hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()).into_inner();
out
});
- chan.pending_outbound_htlcs.push({
+ chan.context.pending_outbound_htlcs.push({
let mut out = OutboundHTLCOutput{
htlc_id: 5,
amount_msat: 5000000,
&channelmanager::provided_init_features(&UserConfig::default()), 10000000, 100000, 42,
&config, 0, 42
).unwrap();
- assert!(!channel_a.channel_type.supports_anchors_zero_fee_htlc_tx());
+ assert!(!channel_a.context.channel_type.supports_anchors_zero_fee_htlc_tx());
let mut expected_channel_type = ChannelTypeFeatures::empty();
expected_channel_type.set_static_remote_key_required();
&open_channel_msg, 7, &config, 0, &&logger, 42
).unwrap();
- assert_eq!(channel_a.channel_type, expected_channel_type);
- assert_eq!(channel_b.channel_type, expected_channel_type);
+ assert_eq!(channel_a.context.channel_type, expected_channel_type);
+ assert_eq!(channel_b.context.channel_type, expected_channel_type);
}
#[cfg(anchors)]
projects / rust-lightning / commitdiff