Load chan mgr from monitors

Author: joostjager

lightning/src/chain/channelmonitor.rs

@@ -2389,14 +2389,17 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 		self.inner.lock().unwrap().sign_to_local_justice_tx(justice_tx, input_idx, value, commitment_number)
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub(crate) fn get_min_seen_secret(&self) -> u64 {
 		self.inner.lock().unwrap().get_min_seen_secret()
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub(crate) fn get_cur_counterparty_commitment_number(&self) -> u64 {
 		self.inner.lock().unwrap().get_cur_counterparty_commitment_number()
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub(crate) fn get_cur_holder_commitment_number(&self) -> u64 {
 		self.inner.lock().unwrap().get_cur_holder_commitment_number()
 	}
@@ -7180,6 +7183,7 @@ mod tests {
 		check_added_monitors(&nodes[1], 1);
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	#[test]
 	fn test_funding_spend_refuses_updates() {
 		do_test_funding_spend_refuses_updates(true);

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -2840,6 +2840,8 @@ fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) {
 	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
 	claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
 }
+
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn channel_holding_cell_serialize() {
 	do_channel_holding_cell_serialize(true, true);
@@ -3313,6 +3315,7 @@ fn do_test_outbound_reload_without_init_mon(use_0conf: bool) {
 	assert!(nodes[0].node.list_channels().is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_outbound_reload_without_init_mon() {
 	do_test_outbound_reload_without_init_mon(true);
@@ -3421,6 +3424,7 @@ fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: boo
 	assert!(nodes[1].node.list_channels().is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_inbound_reload_without_init_mon() {
 	do_test_inbound_reload_without_init_mon(true, true);
@@ -3570,6 +3574,7 @@ fn do_test_blocked_chan_preimage_release(completion_mode: BlockedUpdateComplMode
 	expect_payment_sent(&nodes[2], payment_preimage_2, None, true, true);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_blocked_chan_preimage_release() {
 	do_test_blocked_chan_preimage_release(BlockedUpdateComplMode::AtReload);
@@ -3760,6 +3765,7 @@ fn do_test_inverted_mon_completion_order(
 	expect_payment_sent(&nodes[0], payment_preimage, None, true, true);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_inverted_mon_completion_order() {
 	do_test_inverted_mon_completion_order(true, true);
@@ -3962,6 +3968,7 @@ fn do_test_durable_preimages_on_closed_channel(
 	}
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_durable_preimages_on_closed_channel() {
 	do_test_durable_preimages_on_closed_channel(true, true, true);
@@ -4086,6 +4093,7 @@ fn do_test_reload_mon_update_completion_actions(close_during_reload: bool) {
 	send_payment(&nodes[1], &[&nodes[2]], 100_000);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_reload_mon_update_completion_actions() {
 	do_test_reload_mon_update_completion_actions(true);
@@ -4454,6 +4462,7 @@ fn do_test_partial_claim_mon_update_compl_actions(reload_a: bool, reload_b: bool
 	assert!(!get_monitor!(nodes[3], chan_4_id).get_stored_preimages().contains_key(&payment_hash));
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_partial_claim_mon_update_compl_actions() {
 	do_test_partial_claim_mon_update_compl_actions(true, true);

lightning/src/ln/channel.rs

@@ -2423,6 +2423,7 @@ impl FundingScope {
 		self.channel_transaction_parameters.channel_value_satoshis
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub(crate) fn get_value_to_self_msat(&self) -> u64 {
 		self.value_to_self_msat
 	}
@@ -10853,10 +10854,12 @@ where
 			.try_for_each(|funding| self.context.can_accept_incoming_htlc(funding, dust_exposure_limiting_feerate, &logger))
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub fn get_cur_holder_commitment_transaction_number(&self) -> u64 {
 		self.holder_commitment_point.current_transaction_number()
 	}
 
+	#[cfg(not(feature = "safe_channels"))]
 	pub fn get_cur_counterparty_commitment_transaction_number(&self) -> u64 {
 		self.context.counterparty_next_commitment_transaction_number + 1
 			- if self.context.channel_state.is_awaiting_remote_revoke() { 1 } else { 0 }
@@ -10970,6 +10973,7 @@ where
 	/// transaction. If the channel is inbound, this implies simply that the channel has not
 	/// advanced state.
 	#[rustfmt::skip]
+	#[cfg(not(feature = "safe_channels"))]
 	pub fn is_awaiting_initial_mon_persist(&self) -> bool {
 		if !self.is_awaiting_monitor_update() { return false; }
 		if matches!(

lightning/src/ln/channel_open_tests.rs

@@ -2095,6 +2095,7 @@ pub fn test_batch_channel_open() {
 	)));
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[xtest(feature = "_externalize_tests")]
 pub fn test_close_in_funding_batch() {
 	// This test ensures that if one of the channels
@@ -2183,6 +2184,7 @@ pub fn test_close_in_funding_batch() {
 	assert!(nodes[0].node.list_channels().is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[xtest(feature = "_externalize_tests")]
 pub fn test_batch_funding_close_after_funding_signed() {
 	let chanmon_cfgs = create_chanmon_cfgs(3);

lightning/src/ln/channelmanager.rs

@@ -16769,6 +16769,8 @@ where
 		let mut short_to_chan_info = hash_map_with_capacity(cmp::min(channel_count as usize, 128));
 		let mut channel_closures = VecDeque::new();
 		let mut close_background_events = Vec::new();
+
+		#[cfg(not(feature = "safe_channels"))]
 		for _ in 0..channel_count {
 			let mut channel: FundedChannel<SP> = FundedChannel::read(
 				reader,
@@ -16968,6 +16970,74 @@ where
 			}
 		}
 
+		// Suppress unused mutable variable warning when safe_channels is enabled.
+		#[cfg(feature = "safe_channels")]
+		let _ = &mut args;
+
+		// Discard channel manager versions of channels.
+		#[cfg(feature = "safe_channels")]
+		for _ in 0..channel_count {
+			_ = FundedChannel::read(
+				reader,
+				(
+					&args.entropy_source,
+					&args.signer_provider,
+					&provided_channel_type_features(&args.config),
+				),
+			)?;
+		}
+
+		// Decode channels from monitors.
+		#[cfg(feature = "safe_channels")]
+		for (_, monitor) in args.channel_monitors.iter() {
+			let opt_encoded_channel = monitor.get_encoded_channel();
+			if opt_encoded_channel.is_none() {
+				// Monitor still exists, but there is no more channel state. This can happen after channel shut down.
+				continue;
+			}
+			let encoded_channel = opt_encoded_channel.unwrap();
+			let encoded_channel_reader = &mut &encoded_channel[..];
+			let mut channel: FundedChannel<SP> = FundedChannel::read(
+				encoded_channel_reader,
+				(
+					&args.entropy_source,
+					&args.signer_provider,
+					&provided_channel_type_features(&args.config),
+				),
+			)?;
+			let logger = WithChannelContext::from(&args.logger, &channel.context, None);
+			let channel_id = channel.context.channel_id();
+			channel_id_set.insert(channel_id);
+
+			channel.on_startup_drop_completed_blocked_mon_updates_through(
+				&logger,
+				monitor.get_latest_update_id(),
+			);
+			log_info!(logger, "Successfully loaded at update_id {} against monitor at update id {} with {} blocked updates",
+						channel.context.get_latest_monitor_update_id(),
+						monitor.get_latest_update_id(), channel.blocked_monitor_updates_pending());
+			if let Some(short_channel_id) = channel.funding.get_short_channel_id() {
+				short_to_chan_info.insert(
+					short_channel_id,
+					(channel.context.get_counterparty_node_id(), channel.context.channel_id()),
+				);
+			}
+
+			for short_channel_id in channel.context.historical_scids() {
+				let cp_id = channel.context.get_counterparty_node_id();
+				let chan_id = channel.context.channel_id();
+				short_to_chan_info.insert(*short_channel_id, (cp_id, chan_id));
+			}
+
+			per_peer_state
+				.entry(channel.context.get_counterparty_node_id())
+				.or_insert_with(|| Mutex::new(empty_peer_state()))
+				.get_mut()
+				.unwrap()
+				.channel_by_id
+				.insert(channel.context.channel_id(), Channel::from(channel));
+		}
+
 		for (channel_id, monitor) in args.channel_monitors.iter() {
 			if !channel_id_set.contains(channel_id) {
 				let mut should_queue_fc_update = false;

lightning/src/ln/functional_tests.rs

@@ -9894,6 +9894,7 @@ fn do_test_multi_post_event_actions(do_reload: bool) {
 	check_added_monitors(&nodes[0], 3);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[xtest(feature = "_externalize_tests")]
 pub fn test_multi_post_event_actions() {
 	do_test_multi_post_event_actions(true);

lightning/src/ln/monitor_tests.rs

@@ -2387,6 +2387,7 @@ fn do_test_restored_packages_retry(check_old_monitor_retries_after_upgrade: bool
 	}
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_restored_packages_retry() {
 	do_test_restored_packages_retry(false);
@@ -3021,6 +3022,7 @@ fn do_test_anchors_aggregated_revoked_htlc_tx(p2a_anchor: bool) {
 	assert_eq!(nodes[1].chain_monitor.chain_monitor.get_claimable_balances(&[]).len(), 6);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_anchors_aggregated_revoked_htlc_tx() {
 	do_test_anchors_aggregated_revoked_htlc_tx(false);
@@ -3112,6 +3114,7 @@ fn do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(confirm_c
 	}
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_anchors_monitor_fixes_counterparty_payment_script_on_reload() {
 	do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(false);
@@ -3339,6 +3342,7 @@ fn test_update_replay_panics() {
 	monitor.update_monitor(&updates[3], &nodes[1].tx_broadcaster, &nodes[1].fee_estimator, &nodes[1].logger).unwrap();
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_claim_event_never_handled() {
 	// When a payment is claimed, the `ChannelMonitorUpdate` containing the payment preimage goes
@@ -3566,6 +3570,7 @@ fn do_test_lost_preimage_monitor_events(on_counterparty_tx: bool, p2a_anchor: bo
 	expect_payment_sent(&nodes[0], preimage_a, None, true, true);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_lost_preimage_monitor_events() {
 	do_test_lost_preimage_monitor_events(true, false);
@@ -3811,6 +3816,7 @@ fn do_test_lost_timeout_monitor_events(confirm_tx: CommitmentType, dust_htlcs: b
 	expect_payment_failed!(nodes[0], hash_a, false);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_lost_timeout_monitor_events() {
 	do_test_lost_timeout_monitor_events(CommitmentType::RevokedCounterparty, false, false);

lightning/src/ln/offers_tests.rs

@@ -2430,6 +2430,7 @@ fn rejects_keysend_to_non_static_invoice_path() {
 	expect_payment_failed_conditions(&nodes[0], payment_hash, true, PaymentFailedConditions::new());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn no_double_pay_with_stale_channelmanager() {
 	// This tests the following bug:

lightning/src/ln/onion_route_tests.rs

@@ -1797,6 +1797,7 @@ fn do_test_onion_failure_stale_channel_update(announce_for_forwarding: bool) {
 	assert_eq!(config, config_after_restart);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_onion_failure_stale_channel_update() {
 	do_test_onion_failure_stale_channel_update(false);

lightning/src/ln/payment_tests.rs

@@ -1002,6 +1002,7 @@ fn do_retry_with_no_persist(confirm_before_reload: bool) {
 	expect_payment_sent!(nodes[0], payment_preimage, Some(new_route.paths[0].hops[0].fee_msat));
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn retry_with_no_persist() {
 	do_retry_with_no_persist(true);
@@ -1231,6 +1232,7 @@ fn do_test_completed_payment_not_retryable_on_reload(use_dust: bool) {
 	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_completed_payment_not_retryable_on_reload() {
 	do_test_completed_payment_not_retryable_on_reload(true);
@@ -1409,6 +1411,7 @@ fn do_test_dup_htlc_onchain_doesnt_fail_on_reload(
 	assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_dup_htlc_onchain_doesnt_fail_on_reload() {
 	do_test_dup_htlc_onchain_doesnt_fail_on_reload(true, true, true, true);
@@ -1422,6 +1425,7 @@ fn test_dup_htlc_onchain_doesnt_fail_on_reload() {
 	do_test_dup_htlc_onchain_doesnt_fail_on_reload(false, false, false, false);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_fulfill_restart_failure() {
 	// When we receive an update_fulfill_htlc message, we immediately consider the HTLC fully
@@ -4213,12 +4217,14 @@ fn do_no_missing_sent_on_reload(persist_manager_with_payment: bool, at_midpoint:
 	assert!(events.is_empty());
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn no_missing_sent_on_midpoint_reload() {
 	do_no_missing_sent_on_reload(false, true);
 	do_no_missing_sent_on_reload(true, true);
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn no_missing_sent_on_reload() {
 	do_no_missing_sent_on_reload(false, false);
@@ -4932,6 +4938,7 @@ fn do_test_payment_metadata_consistency(do_reload: bool, do_modify: bool) {
 	}
 }
 
+#[cfg(not(feature = "safe_channels"))]
 #[test]
 fn test_payment_metadata_consistency() {
 	do_test_payment_metadata_consistency(true, true);