]> git.bitcoin.ninja Git - rust-lightning/commitdiff
Move `Channel` fields into `ChannelContext` struct
authorDuncan Dean <duncangleeddean@gmail.com>
Tue, 7 Mar 2023 19:56:01 +0000 (21:56 +0200)
committerDuncan Dean <git@dunxen.dev>
Wed, 14 Jun 2023 11:42:22 +0000 (13:42 +0200)
This is a first step for simplifying the channel state and introducing
new unfunded channel types that hold similar state before being promoted
to funded channels.

Essentially, we want the outer `Channel` type (and upcoming channel types)
to wrap the context so we can apply typestate patterns to the that wrapper
while also deduplicating code for common state and other internal fields.

lightning/src/ln/chanmon_update_fail_tests.rs
lightning/src/ln/channel.rs
lightning/src/ln/channelmanager.rs
lightning/src/ln/functional_tests.rs
lightning/src/ln/shutdown_tests.rs

index 015650cb82312523627902a87008366762a1313f..707c27908eddabd5efdbabeda8278af225b02950 100644 (file)
@@ -1456,12 +1456,12 @@ fn monitor_failed_no_reestablish_response() {
        {
                let mut node_0_per_peer_lock;
                let mut node_0_peer_state_lock;
-               get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, channel_id).announcement_sigs_state = AnnouncementSigsState::PeerReceived;
+               get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, channel_id).context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
        }
        {
                let mut node_1_per_peer_lock;
                let mut node_1_peer_state_lock;
-               get_channel_ref!(nodes[1], nodes[0], node_1_per_peer_lock, node_1_peer_state_lock, channel_id).announcement_sigs_state = AnnouncementSigsState::PeerReceived;
+               get_channel_ref!(nodes[1], nodes[0], node_1_per_peer_lock, node_1_peer_state_lock, channel_id).context.announcement_sigs_state = AnnouncementSigsState::PeerReceived;
        }
 
        // Route the payment and deliver the initial commitment_signed (with a monitor update failure
index 8cb73241562e7187deebd75dd3e3ef8858a9abc6..195e261fe6f785568f0013ebc16d10460e51c4bf 100644 (file)
@@ -491,7 +491,7 @@ pub(crate) const EXPIRE_PREV_CONFIG_TICKS: usize = 5;
 /// [`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 {
@@ -509,14 +509,8 @@ impl_writeable_tlv_based!(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
@@ -790,6 +784,17 @@ pub(super) struct Channel<Signer: ChannelSigner> {
        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,
@@ -920,7 +925,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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 {
@@ -953,8 +958,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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(());
                }
@@ -967,14 +972,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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))
        }
@@ -1049,130 +1054,132 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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(),
+                       }
                })
        }
 
@@ -1406,133 +1413,135 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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)
@@ -1556,16 +1565,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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.
@@ -1580,7 +1589,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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) => {
@@ -1628,7 +1637,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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"),
@@ -1657,7 +1666,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                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"),
@@ -1696,13 +1705,13 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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)]
@@ -1710,18 +1719,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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 {
@@ -1751,12 +1760,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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(),
@@ -1790,7 +1799,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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]
@@ -1822,13 +1831,13 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
        #[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());
@@ -1838,17 +1847,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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);
@@ -1856,7 +1865,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        fn funding_outpoint(&self) -> OutPoint {
-               self.channel_transaction_parameters.funding_outpoint.unwrap()
+               self.context.channel_transaction_parameters.funding_outpoint.unwrap()
        }
 
        #[inline]
@@ -1866,12 +1875,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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]
@@ -1885,7 +1894,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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
@@ -1908,10 +1917,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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.
                }
@@ -1922,10 +1931,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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());
 
@@ -1935,7 +1944,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                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 {
@@ -1962,7 +1971,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        #[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 {};
                }
 
@@ -1970,27 +1979,27 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                //
                // 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 {};
                                                }
                                        },
@@ -2006,25 +2015,25 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        _ => {}
                                }
                        }
-                       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()));
                }
 
@@ -2040,7 +2049,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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
@@ -2052,28 +2061,28 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        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,
                                                });
                                        }
@@ -2081,7 +2090,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                };
                                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,
                                }
@@ -2114,17 +2123,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// [`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 => {},
@@ -2147,23 +2156,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        #[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);
                                                }
                                        },
@@ -2177,7 +2186,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                }
                        }
                        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,
                        });
@@ -2186,7 +2195,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                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()));
                }
 
@@ -2200,29 +2209,29 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        // 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)));
                }
@@ -2261,7 +2270,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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() {
@@ -2271,7 +2280,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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() {
@@ -2294,16 +2303,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                } 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 {
@@ -2314,16 +2323,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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(())
        }
@@ -2331,29 +2340,29 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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.
@@ -2374,31 +2383,31 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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) => {
@@ -2416,7 +2425,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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:
@@ -2424,23 +2433,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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()));
 
@@ -2448,7 +2457,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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,
@@ -2467,33 +2476,33 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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()));
                        }
                }
@@ -2506,7 +2515,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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()))?;
 
 
@@ -2514,23 +2523,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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()));
 
@@ -2550,49 +2559,49 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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) {
@@ -2603,8 +2612,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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()));
 
@@ -2613,8 +2622,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
        /// 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
                }
@@ -2623,7 +2632,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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,
@@ -2638,9 +2647,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        (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;
@@ -2655,7 +2664,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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,
@@ -2670,9 +2679,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        (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;
@@ -2682,7 +2691,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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;
@@ -2709,18 +2718,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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;
 
@@ -2732,9 +2741,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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);
@@ -2758,16 +2767,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                } 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 {
@@ -2777,7 +2786,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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.
@@ -2787,11 +2796,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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 {
@@ -2817,17 +2826,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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,
@@ -2837,7 +2846,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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.
@@ -2871,11 +2880,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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; }
@@ -2893,7 +2902,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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
                        }
@@ -2902,7 +2911,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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
                        }
@@ -2917,7 +2926,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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 {
@@ -2931,29 +2940,29 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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
        }
@@ -2974,11 +2983,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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; }
@@ -2999,14 +3008,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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
                        }
@@ -3021,28 +3030,28 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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
        }
@@ -3050,35 +3059,35 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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
@@ -3093,7 +3102,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 {
@@ -3108,7 +3117,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        (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() {
@@ -3118,7 +3127,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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() {
@@ -3129,9 +3138,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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()));
                }
@@ -3146,7 +3155,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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()));
                }
 
@@ -3161,7 +3170,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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()));
@@ -3171,26 +3180,26 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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,
@@ -3204,7 +3213,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        #[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(),
@@ -3232,10 +3241,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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()));
                }
 
@@ -3243,10 +3252,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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()));
                }
 
@@ -3255,10 +3264,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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()));
                }
 
@@ -3269,31 +3278,31 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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
@@ -3302,12 +3311,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                // 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()));
                        }
@@ -3315,15 +3324,15 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                #[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);
                                                }
                                }
@@ -3363,7 +3372,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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 {
@@ -3388,34 +3397,34 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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);
@@ -3433,9 +3442,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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,
@@ -3444,39 +3453,39 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }]
                };
 
-               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 };
@@ -3491,8 +3500,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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()) }
        }
@@ -3500,18 +3509,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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());
@@ -3579,10 +3588,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        },
                                }
                        }
-                       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
@@ -3591,7 +3600,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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.",
@@ -3613,25 +3622,25 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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
@@ -3644,22 +3653,22 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                #[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,
                        }],
                };
@@ -3668,14 +3677,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // (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()));
@@ -3688,9 +3697,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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| {
@@ -3769,54 +3778,54 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                }
                        }
                }
-               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);
@@ -3828,7 +3837,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                                        // 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.",
@@ -3873,11 +3882,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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;
@@ -3895,20 +3904,20 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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,
                })
        }
@@ -3919,30 +3928,30 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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.
@@ -3967,16 +3976,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                },
                        }
                });
-               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
@@ -3985,9 +3994,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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()));
        }
 
@@ -4007,13 +4016,13 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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
@@ -4027,10 +4036,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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
@@ -4040,12 +4049,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // (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;
                }
 
@@ -4055,47 +4064,47 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // * 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" },
@@ -4111,14 +4120,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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.
@@ -4140,10 +4149,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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)]
@@ -4157,7 +4166,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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(),
@@ -4170,7 +4179,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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) => {
@@ -4199,10 +4208,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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 };
 
@@ -4230,7 +4239,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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.
@@ -4243,17 +4252,17 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                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\
@@ -4269,7 +4278,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                // 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))
@@ -4278,23 +4287,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                // 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()));
                                }
@@ -4308,12 +4317,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
 
                        // 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,
@@ -4321,13 +4330,13 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        });
                }
 
-               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())
@@ -4340,19 +4349,19 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 };
 
@@ -4367,7 +4376,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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() {
@@ -4376,19 +4385,19 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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 {
@@ -4403,7 +4412,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                -> (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.
@@ -4418,8 +4427,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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);
                }
@@ -4431,20 +4440,20 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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
@@ -4452,12 +4461,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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
@@ -4465,10 +4474,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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(())
@@ -4479,12 +4488,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                -> 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));
@@ -4492,18 +4501,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                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 {
@@ -4517,7 +4526,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        // [`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
@@ -4525,7 +4534,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        ///
        /// 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.
@@ -4540,40 +4549,40 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        ) -> 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);
@@ -4584,32 +4593,32 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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 };
@@ -4617,9 +4626,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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()));
@@ -4629,8 +4638,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                });
 
-               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))
        }
@@ -4663,25 +4672,25 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                -> 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));
                }
 
@@ -4690,16 +4699,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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());
                        },
                };
 
@@ -4709,12 +4718,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                }
 
-               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)));
                        }
                }
@@ -4729,20 +4738,20 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        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 {
@@ -4767,7 +4776,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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 {
@@ -4780,7 +4789,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                } 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);
@@ -4813,105 +4822,105 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        // 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)
@@ -4920,111 +4929,111 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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
        }
 
@@ -5066,7 +5075,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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 {
@@ -5075,10 +5084,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 {
@@ -5088,33 +5097,33 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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;
@@ -5124,72 +5133,72 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                }
                                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
@@ -5198,8 +5207,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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
@@ -5211,15 +5220,15 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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
@@ -5228,18 +5237,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        }
 
        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.
@@ -5248,16 +5257,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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
@@ -5270,9 +5279,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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
@@ -5280,68 +5289,68 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
        /// 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,
@@ -5349,25 +5358,25 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                #[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
@@ -5388,11 +5397,11 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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
@@ -5402,7 +5411,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                                                #[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 {
@@ -5416,9 +5425,9 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                                                        }
                                                                }
                                                        }
-                                                       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"),
                                                        }
@@ -5428,7 +5437,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        // 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));
                                        }
@@ -5479,7 +5488,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 {
@@ -5491,21 +5500,21 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        }
                });
 
-               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
@@ -5521,14 +5530,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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);
@@ -5545,14 +5554,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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?");
@@ -5575,52 +5584,52 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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
@@ -5631,18 +5640,18 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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()
        }
@@ -5653,29 +5662,29 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        ///
        /// [`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,
                }
@@ -5693,8 +5702,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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)
        }
 
@@ -5709,34 +5718,34 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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,
@@ -5762,7 +5771,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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() {
@@ -5796,7 +5805,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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;
                }
 
@@ -5804,12 +5813,12 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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;
                }
 
@@ -5828,14 +5837,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        },
                        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(),
@@ -5850,14 +5859,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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 },
@@ -5882,19 +5891,19 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                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()));
                }
@@ -5907,7 +5916,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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) {
@@ -5923,8 +5932,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        /// 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.
@@ -5933,8 +5942,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 {
@@ -5953,7 +5962,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                        // 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
@@ -5961,7 +5970,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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
@@ -6011,10 +6020,10 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
        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)));
                }
@@ -6034,7 +6043,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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
@@ -6044,7 +6053,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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" }
@@ -6056,7 +6065,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
                // 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,
@@ -6066,8 +6075,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        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,
@@ -6076,14 +6085,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                });
 
                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))
        }
@@ -6093,7 +6102,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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 };
@@ -6102,7 +6111,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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
@@ -6111,55 +6120,55 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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);
                                                }
                                }
@@ -6177,7 +6186,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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);
 
@@ -6187,7 +6196,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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;
@@ -6207,7 +6216,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                }
 
                Ok((msgs::CommitmentSigned {
-                       channel_id: self.channel_id,
+                       channel_id: self.context.channel_id,
                        signature,
                        htlc_signatures,
                        #[cfg(taproot)]
@@ -6235,14 +6244,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
 
        /// 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
@@ -6260,35 +6269,35 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                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
@@ -6305,44 +6314,44 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                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()));
@@ -6368,16 +6377,16 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                // 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));
                                },
                                _ => {}
                        }
@@ -6390,22 +6399,22 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                        // 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, .. }
@@ -6413,7 +6422,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Channel<Signer> {
                                        _ => 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)))
        }
 }
 
@@ -6484,7 +6493,7 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                // `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
@@ -6492,14 +6501,14 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                // `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)?;
@@ -6507,24 +6516,24 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 
                // 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
                        }
@@ -6554,8 +6563,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
 
                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)?;
@@ -6593,8 +6602,8 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                        }
                }
 
-               (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)?;
@@ -6617,43 +6626,43 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                        }
                }
 
-               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
@@ -6661,25 +6670,25 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                // 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)?;
@@ -6689,23 +6698,23 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                        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)?;
                }
 
@@ -6713,62 +6722,62 @@ impl<Signer: WriteableEcdsaChannelSigner> Writeable for Channel<Signer> {
                // 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(())
@@ -7125,122 +7134,124 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
                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(),
+                       }
                })
        }
 }
@@ -7428,11 +7439,11 @@ mod tests {
                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()),
@@ -7440,7 +7451,7 @@ mod tests {
                        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()),
@@ -7458,13 +7469,13 @@ mod tests {
                // 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);
@@ -7486,32 +7497,32 @@ mod tests {
                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);
@@ -7597,13 +7608,13 @@ mod tests {
                // `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());
 
@@ -7611,39 +7622,39 @@ mod tests {
                // `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]
@@ -7683,8 +7694,8 @@ mod tests {
                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();
@@ -7693,10 +7704,10 @@ mod tests {
                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);
@@ -7717,8 +7728,8 @@ mod tests {
                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.
@@ -7741,7 +7752,7 @@ mod tests {
 
                // 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);
@@ -7796,8 +7807,8 @@ mod tests {
                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 };
 
@@ -7808,13 +7819,13 @@ mod tests {
                        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()[..]);
@@ -7828,22 +7839,22 @@ mod tests {
                // 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)*);
                        };
                }
@@ -7864,7 +7875,7 @@ mod tests {
                                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");
 
@@ -7883,7 +7894,7 @@ mod tests {
                                        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();
@@ -7901,7 +7912,7 @@ mod tests {
                                        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);
@@ -7928,7 +7939,7 @@ mod tests {
                                        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))[..],
@@ -7944,7 +7955,7 @@ mod tests {
                                                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80024a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f10529800000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e0400473044022007cf6b405e9c9b4f527b0ecad9d8bb661fabb8b12abf7d1c0b3ad1855db3ed490220616d5c1eeadccc63bd775a131149455d62d95a42c2a1b01cc7821fc42dce7778014730440220655bf909fb6fa81d086f1336ac72c97906dce29d1b166e305c99152d810e26e1022051f577faa46412c46707aaac46b65d50053550a66334e00a44af2706f27a865801475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
 
                // simple commitment tx with no HTLCs
-               chan.value_to_self_msat = 7000000000;
+               chan.context.value_to_self_msat = 7000000000;
 
                test_commitment!("3045022100c3127b33dcc741dd6b05b1e63cbd1a9a7d816f37af9b6756fa2376b056f032370220408b96279808fe57eb7e463710804cdf4f108388bc5cf722d8c848d2c7f9f3b0",
                                                 "30440220616210b2cc4d3afb601013c373bbd8aac54febd9f15400379a8cb65ce7deca60022034236c010991beb7ff770510561ae8dc885b8d38d1947248c38f2ae055647142",
@@ -7955,7 +7966,7 @@ mod tests {
                                                 "30450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f7",
                                                 "02000000000101bef67e4e2fb9ddeeb3461973cd4c62abb35050b1add772995b820b584a488489000000000038b02b80044a010000000000002200202b1b5854183c12d3316565972c4668929d314d81c5dcdbb21cb45fe8a9a8114f4a01000000000000220020e9e86e4823faa62e222ebc858a226636856158f07e69898da3b0d1af0ddb3994c0c62d0000000000220020f3394e1e619b0eca1f91be2fb5ab4dfc59ba5b84ebe014ad1d43a564d012994a508b6a00000000002200204adb4e2f00643db396dd120d4e7dc17625f5f2c11a40d857accc862d6b7dd80e04004830450221008266ac6db5ea71aac3c95d97b0e172ff596844851a3216eb88382a8dddfd33d2022050e240974cfd5d708708b4365574517c18e7ae535ef732a3484d43d0d82be9f701483045022100f89034eba16b2be0e5581f750a0a6309192b75cce0f202f0ee2b4ec0cc394850022076c65dc507fe42276152b7a3d90e961e678adbe966e916ecfe85e64d430e75f301475221023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb21030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c152ae3e195220", {});
 
-               chan.pending_inbound_htlcs.push({
+               chan.context.pending_inbound_htlcs.push({
                        let mut out = InboundHTLCOutput{
                                htlc_id: 0,
                                amount_msat: 1000000,
@@ -7966,7 +7977,7 @@ mod tests {
                        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,
@@ -7977,7 +7988,7 @@ mod tests {
                        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,
@@ -7989,7 +8000,7 @@ mod tests {
                        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,
@@ -8001,7 +8012,7 @@ mod tests {
                        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,
@@ -8014,8 +8025,8 @@ mod tests {
                });
 
                // 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",
@@ -8048,8 +8059,8 @@ mod tests {
                } );
 
                // 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",
@@ -8082,8 +8093,8 @@ mod tests {
                } );
 
                // 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",
@@ -8111,9 +8122,9 @@ mod tests {
                } );
 
                // 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",
@@ -8141,9 +8152,9 @@ mod tests {
                } );
 
                // 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",
@@ -8171,8 +8182,8 @@ mod tests {
                } );
 
                // 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",
@@ -8195,8 +8206,8 @@ mod tests {
                } );
 
                // 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",
@@ -8219,8 +8230,8 @@ mod tests {
                } );
 
                // 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",
@@ -8238,9 +8249,9 @@ mod tests {
                } );
 
                // 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",
@@ -8258,9 +8269,9 @@ mod tests {
                } );
 
                // 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",
@@ -8278,8 +8289,8 @@ mod tests {
                } );
 
                // 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",
@@ -8292,9 +8303,9 @@ mod tests {
                } );
 
                // 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",
@@ -8307,9 +8318,9 @@ mod tests {
                } );
 
                // 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",
@@ -8322,63 +8333,63 @@ mod tests {
                } );
 
                // 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,
@@ -8389,8 +8400,8 @@ mod tests {
                        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,
@@ -8402,7 +8413,7 @@ mod tests {
                        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,
@@ -8553,7 +8564,7 @@ mod tests {
                        &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();
@@ -8571,8 +8582,8 @@ mod tests {
                        &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)]
index 7c065f1ba44c4d956f68d791f52ad75c8135c74e..8872ae6d42d54e60687c55eb80f6954cd1634913 100644 (file)
@@ -5623,7 +5623,7 @@ where
                                                        });
                                                }
                                        }
-                                       let need_lnd_workaround = chan.get_mut().workaround_lnd_bug_4006.take();
+                                       let need_lnd_workaround = chan.get_mut().context.workaround_lnd_bug_4006.take();
                                        htlc_forwards = self.handle_channel_resumption(
                                                &mut peer_state.pending_msg_events, chan.get_mut(), responses.raa, responses.commitment_update, responses.order,
                                                Vec::new(), None, responses.channel_ready, responses.announcement_sigs);
index 0775f58bbcadb309508c3291846c36941d742eea..1caf1340a96e6c10d880ad68484662e28a52fe70 100644 (file)
@@ -180,8 +180,8 @@ fn do_test_counterparty_no_reserve(send_from_initiator: bool) {
                let mut sender_node_per_peer_lock;
                let mut sender_node_peer_state_lock;
                let mut chan = get_channel_ref!(sender_node, counterparty_node, sender_node_per_peer_lock, sender_node_peer_state_lock, temp_channel_id);
-               chan.holder_selected_channel_reserve_satoshis = 0;
-               chan.holder_max_htlc_value_in_flight_msat = 100_000_000;
+               chan.context.holder_selected_channel_reserve_satoshis = 0;
+               chan.context.holder_max_htlc_value_in_flight_msat = 100_000_000;
        }
 
        let funding_tx = sign_funding_transaction(&nodes[0], &nodes[1], 100_000, temp_channel_id);
@@ -728,7 +728,7 @@ fn test_update_fee_that_funder_cannot_afford() {
                        commit_tx_keys.clone(),
                        non_buffer_feerate + 4,
                        &mut htlcs,
-                       &local_chan.channel_transaction_parameters.as_counterparty_broadcastable()
+                       &local_chan.context.channel_transaction_parameters.as_counterparty_broadcastable()
                );
                local_chan_signer.sign_counterparty_commitment(&commitment_tx, Vec::new(), &secp_ctx).unwrap()
        };
@@ -1457,7 +1457,7 @@ fn test_fee_spike_violation_fails_htlc() {
                        commit_tx_keys.clone(),
                        feerate_per_kw,
                        &mut vec![(accepted_htlc_info, ())],
-                       &local_chan.channel_transaction_parameters.as_counterparty_broadcastable()
+                       &local_chan.context.channel_transaction_parameters.as_counterparty_broadcastable()
                );
                local_chan_signer.sign_counterparty_commitment(&commitment_tx, Vec::new(), &secp_ctx).unwrap()
        };
@@ -3122,7 +3122,7 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
                // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
                // well, so HTLCs at exactly the dust limit will not be included in commitment txn.
                nodes[2].node.per_peer_state.read().unwrap().get(&nodes[1].node.get_our_node_id())
-                       .unwrap().lock().unwrap().channel_by_id.get(&chan_2.2).unwrap().holder_dust_limit_satoshis * 1000
+                       .unwrap().lock().unwrap().channel_by_id.get(&chan_2.2).unwrap().context.holder_dust_limit_satoshis * 1000
        } else { 3000000 };
 
        let (_, first_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
@@ -4990,7 +4990,7 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
        assert_eq!(get_local_commitment_txn!(nodes[3], chan_2_3.2)[0].output.len(), 2);
 
        let ds_dust_limit = nodes[3].node.per_peer_state.read().unwrap().get(&nodes[2].node.get_our_node_id())
-               .unwrap().lock().unwrap().channel_by_id.get(&chan_2_3.2).unwrap().holder_dust_limit_satoshis;
+               .unwrap().lock().unwrap().channel_by_id.get(&chan_2_3.2).unwrap().context.holder_dust_limit_satoshis;
        // 0th HTLC:
        let (_, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
        // 1st HTLC:
@@ -6099,7 +6099,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment()
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0);
        let max_accepted_htlcs = nodes[1].node.per_peer_state.read().unwrap().get(&nodes[0].node.get_our_node_id())
-               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().counterparty_max_accepted_htlcs as u64;
+               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().context.counterparty_max_accepted_htlcs as u64;
 
        // Fetch a route in advance as we will be unable to once we're unable to send.
        let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 100000);
@@ -6774,7 +6774,7 @@ fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
        let chan =create_announced_chan_between_nodes(&nodes, 0, 1);
 
        let bs_dust_limit = nodes[1].node.per_peer_state.read().unwrap().get(&nodes[0].node.get_our_node_id())
-               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
+               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().context.holder_dust_limit_satoshis;
 
        // We route 2 dust-HTLCs between A and B
        let (_, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
@@ -6867,7 +6867,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
        let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 
        let bs_dust_limit = nodes[1].node.per_peer_state.read().unwrap().get(&nodes[0].node.get_our_node_id())
-               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
+               .unwrap().lock().unwrap().channel_by_id.get(&chan.2).unwrap().context.holder_dust_limit_satoshis;
 
        let (_payment_preimage_1, dust_hash, _payment_secret_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
        let (_payment_preimage_2, non_dust_hash, _payment_secret_2) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
@@ -9604,7 +9604,7 @@ fn do_test_max_dust_htlc_exposure(dust_outbound_balance: bool, exposure_breach_e
                let mut node_0_per_peer_lock;
                let mut node_0_peer_state_lock;
                let mut chan = get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, temporary_channel_id);
-               chan.holder_dust_limit_satoshis = 546;
+               chan.context.holder_dust_limit_satoshis = 546;
        }
 
        nodes[0].node.funding_transaction_generated(&temporary_channel_id, &nodes[1].node.get_our_node_id(), tx.clone()).unwrap();
index d3823fc8f9e1c85c25db75da3eb944dae5a76bf8..a2ec37a8abbaf113afe57e5bbcaa1fdafcbc40a0 100644 (file)
@@ -837,7 +837,7 @@ fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) {
                {
                        let mut node_0_per_peer_lock;
                        let mut node_0_peer_state_lock;
-                       get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).closing_fee_limits.as_mut().unwrap().1 *= 10;
+                       get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context.closing_fee_limits.as_mut().unwrap().1 *= 10;
                }
                nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
                let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());