Use data.* directly for simple fields in ChannelManager::read

Instead of destructuring all DTO fields into local variables, access
simple read-only fields directly via data.* and only extract fields
that need mutation into local variables.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: joostjager

lightning/src/ln/channelmanager.rs

@@ -17851,33 +17851,18 @@ where
 		)?;
 
 		// Stage 2: Validation and reconstruction
-		// Destructure DTO into local variables for the existing validation logic
-		let chain_hash = data.chain_hash;
-		let best_block_height = data.best_block_height;
-		let best_block_hash = data.best_block_hash;
+		// Extract mutable/complex fields into local variables; simple fields accessed via data.*
 		let mut forward_htlcs_legacy = data.forward_htlcs;
 		let mut claimable_htlcs_list = data.claimable_htlcs;
-		let highest_seen_timestamp = data.highest_seen_timestamp;
-		let pending_outbound_payments_compat = data.pending_outbound_payments_compat;
-		let pending_outbound_payments_no_retry = data.pending_outbound_payments_no_retry;
 		let mut pending_intercepted_htlcs_legacy =
-			data.pending_intercepted_htlcs.unwrap_or_else(|| new_hash_map());
+			data.pending_intercepted_htlcs.unwrap_or_else(new_hash_map);
 		let mut pending_outbound_payments = data.pending_outbound_payments;
-		let pending_claiming_payments = data.pending_claiming_payments;
-		let received_network_pubkey = data.received_network_pubkey;
-		let monitor_update_blocked_actions_per_peer = data.monitor_update_blocked_actions_per_peer;
 		let mut fake_scid_rand_bytes = data.fake_scid_rand_bytes;
-		let events_override = data.events_override;
-		let claimable_htlc_purposes = data.claimable_htlc_purposes;
-		let legacy_in_flight_monitor_updates = data.legacy_in_flight_monitor_updates;
 		let mut probing_cookie_secret = data.probing_cookie_secret;
-		let claimable_htlc_onion_fields = data.claimable_htlc_onion_fields;
 		let mut decode_update_add_htlcs_legacy =
-			data.decode_update_add_htlcs.unwrap_or_else(|| new_hash_map());
+			data.decode_update_add_htlcs.unwrap_or_else(new_hash_map);
 		let mut inbound_payment_id_secret = data.inbound_payment_id_secret;
 		let mut in_flight_monitor_updates = data.in_flight_monitor_updates;
-		let peer_storage_dir = data.peer_storage_dir.unwrap_or_else(Vec::new);
-		let async_receive_offer_cache = data.async_receive_offer_cache;
 		let mut pending_events_read = data.pending_events;
 
 		let empty_peer_state = || PeerState {
@@ -18174,34 +18159,37 @@ where
 			inbound_payment_id_secret = Some(args.entropy_source.get_secure_random_bytes());
 		}
 
-		if let Some(events) = events_override {
+		if let Some(events) = data.events_override {
 			pending_events_read = events;
 		}
 
 		if !channel_closures.is_empty() {
 			pending_events_read.append(&mut channel_closures);
 		}
 
-		if pending_outbound_payments.is_none() && pending_outbound_payments_no_retry.is_none() {
-			pending_outbound_payments = Some(pending_outbound_payments_compat);
+		if pending_outbound_payments.is_none() && data.pending_outbound_payments_no_retry.is_none()
+		{
+			pending_outbound_payments = Some(data.pending_outbound_payments_compat);
 		} else if pending_outbound_payments.is_none() {
 			let mut outbounds = new_hash_map();
-			for (id, session_privs) in pending_outbound_payments_no_retry.unwrap().drain() {
+			for (id, session_privs) in data.pending_outbound_payments_no_retry.unwrap().drain() {
 				outbounds.insert(id, PendingOutboundPayment::Legacy { session_privs });
 			}
 			pending_outbound_payments = Some(outbounds);
 		}
 		let pending_outbounds =
 			OutboundPayments::new(pending_outbound_payments.unwrap(), args.logger.clone());
 
-		for (peer_pubkey, peer_storage) in peer_storage_dir {
-			if let Some(peer_state) = per_peer_state.get_mut(&peer_pubkey) {
-				peer_state.get_mut().unwrap().peer_storage = peer_storage;
+		if let Some(peer_storage_dir) = data.peer_storage_dir {
+			for (peer_pubkey, peer_storage) in peer_storage_dir {
+				if let Some(peer_state) = per_peer_state.get_mut(&peer_pubkey) {
+					peer_state.get_mut().unwrap().peer_storage = peer_storage;
+				}
 			}
 		}
 
 		// Handle transitioning from the legacy TLV to the new one on upgrades.
-		if let Some(legacy_in_flight_upds) = legacy_in_flight_monitor_updates {
+		if let Some(legacy_in_flight_upds) = data.legacy_in_flight_monitor_updates {
 			// We should never serialize an empty map.
 			if legacy_in_flight_upds.is_empty() {
 				return Err(DecodeError::InvalidValue);
@@ -18544,7 +18532,7 @@ where
 								htlc.payment_hash,
 								session_priv_bytes,
 								&path,
-								best_block_height,
+								data.best_block_height,
 							);
 						}
 					}
@@ -18846,11 +18834,11 @@ where
 		let expanded_inbound_key = args.node_signer.get_expanded_key();
 
 		let mut claimable_payments = hash_map_with_capacity(claimable_htlcs_list.len());
-		if let Some(purposes) = claimable_htlc_purposes {
+		if let Some(purposes) = data.claimable_htlc_purposes {
 			if purposes.len() != claimable_htlcs_list.len() {
 				return Err(DecodeError::InvalidValue);
 			}
-			if let Some(onion_fields) = claimable_htlc_onion_fields {
+			if let Some(onion_fields) = data.claimable_htlc_onion_fields {
 				if onion_fields.len() != claimable_htlcs_list.len() {
 					return Err(DecodeError::InvalidValue);
 				}
@@ -18948,7 +18936,7 @@ where
 			Ok(key) => key,
 			Err(()) => return Err(DecodeError::InvalidValue),
 		};
-		if let Some(network_pubkey) = received_network_pubkey {
+		if let Some(network_pubkey) = data.received_network_pubkey {
 			if network_pubkey != our_network_pubkey {
 				log_error!(args.logger, "Key that was generated does not match the existing key.");
 				return Err(DecodeError::InvalidValue);
@@ -18967,8 +18955,8 @@ where
 						loop {
 							outbound_scid_alias = fake_scid::Namespace::OutboundAlias
 								.get_fake_scid(
-									best_block_height,
-									&chain_hash,
+									data.best_block_height,
+									&data.chain_hash,
 									fake_scid_rand_bytes.as_ref().unwrap(),
 									&args.entropy_source,
 								);
@@ -19015,7 +19003,7 @@ where
 		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(args.fee_estimator);
 
 		for (node_id, monitor_update_blocked_actions) in
-			monitor_update_blocked_actions_per_peer.unwrap()
+			data.monitor_update_blocked_actions_per_peer.unwrap()
 		{
 			if let Some(peer_state) = per_peer_state.get(&node_id) {
 				for (channel_id, actions) in monitor_update_blocked_actions.iter() {
@@ -19144,22 +19132,22 @@ where
 			}
 		}
 
-		let best_block = BestBlock::new(best_block_hash, best_block_height);
+		let best_block = BestBlock::new(data.best_block_hash, data.best_block_height);
 		let flow = OffersMessageFlow::new(
-			chain_hash,
+			data.chain_hash,
 			best_block,
 			our_network_pubkey,
-			highest_seen_timestamp,
+			data.highest_seen_timestamp,
 			expanded_inbound_key,
 			args.node_signer.get_receive_auth_key(),
 			secp_ctx.clone(),
 			args.message_router,
 			args.logger.clone(),
 		)
-		.with_async_payments_offers_cache(async_receive_offer_cache);
+		.with_async_payments_offers_cache(data.async_receive_offer_cache);
 
 		let channel_manager = ChannelManager {
-			chain_hash,
+			chain_hash: data.chain_hash,
 			fee_estimator: bounded_fee_estimator,
 			chain_monitor: args.chain_monitor,
 			tx_broadcaster: args.tx_broadcaster,
@@ -19176,7 +19164,7 @@ where
 			decode_update_add_htlcs: Mutex::new(decode_update_add_htlcs),
 			claimable_payments: Mutex::new(ClaimablePayments {
 				claimable_payments,
-				pending_claiming_payments: pending_claiming_payments.unwrap(),
+				pending_claiming_payments: data.pending_claiming_payments.unwrap(),
 			}),
 			outbound_scid_aliases: Mutex::new(outbound_scid_aliases),
 			short_to_chan_info: FairRwLock::new(short_to_chan_info),
@@ -19188,7 +19176,7 @@ where
 			our_network_pubkey,
 			secp_ctx,
 
-			highest_seen_timestamp: AtomicUsize::new(highest_seen_timestamp as usize),
+			highest_seen_timestamp: AtomicUsize::new(data.highest_seen_timestamp as usize),
 
 			per_peer_state: FairRwLock::new(per_peer_state),
 
@@ -19500,7 +19488,7 @@ where
 		//TODO: Broadcast channel update for closed channels, but only after we've made a
 		//connection or two.
 
-		Ok((best_block_hash.clone(), channel_manager))
+		Ok((data.best_block_hash, channel_manager))
 	}
 }