Cache peers in Flow

In upcoming commits, we'll move to creating multi-hop blinded paths during the
process of creating a revoke_and_ack message within the Channel struct.  These
paths will be included in said RAA to be used as reply paths for often-offline
senders held_htlc_available messages.

Because we hold the per-peer lock corresponding to the Channel while creating
this RAA, we can't use our typical approach of calling
ChannelManager::get_peers_for_blinded_path to create these blinded paths.
The ::get_peers method takes each peer's lock in turn in order to check for
usable channels/onion message feature support, and it's not permitted to hold
multiple peer state locks at the same time due to the potential for deadlocks
(see the debug_sync module).

To avoid taking other peer state locks while holding a particular Channel's
peer state lock, here we cache the set of peers in the OffersMessageFlow, which
is the struct that ultimately creates the blinded paths for the RAA.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -8077,6 +8077,8 @@ where
 
 			should_persist
 		});
+
+		self.flow.set_peers(self.get_peers_for_blinded_path());
 	}
 
 	/// Indicates that the preimage for payment_hash is unknown or the received amount is incorrect
@@ -10427,16 +10429,20 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						emit_initial_channel_ready_event!(pending_events, chan);
 					}
 
-					Ok(())
 				} else {
 					try_channel_entry!(self, peer_state, Err(ChannelError::close(
 						"Got a channel_ready message for an unfunded channel!".into())), chan_entry)
 				}
 			},
 			hash_map::Entry::Vacant(_) => {
-				Err(MsgHandleErrInternal::send_err_msg_no_close(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", counterparty_node_id), msg.channel_id))
+				return Err(MsgHandleErrInternal::send_err_msg_no_close(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", counterparty_node_id), msg.channel_id))
 			}
 		}
+		core::mem::drop(peer_state_lock);
+		core::mem::drop(per_peer_state);
+
+		self.flow.set_peers(self.get_peers_for_blinded_path());
+		Ok(())
 	}
 
 	fn internal_shutdown(
@@ -10530,6 +10536,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 			self.fail_htlc_backwards_internal(&source, &hash, &reason, receiver, None);
 		}
 
+		self.flow.set_peers(self.get_peers_for_blinded_path());
 		Ok(())
 	}
 
@@ -13391,6 +13398,8 @@ where
 		for (err, counterparty_node_id) in failed_channels.drain(..) {
 			let _ = handle_error!(self, err, counterparty_node_id);
 		}
+
+		self.flow.set_peers(self.get_peers_for_blinded_path());
 	}
 
 	#[rustfmt::skip]
@@ -13503,6 +13512,7 @@ where
 		// until we have some peer connection(s) to receive onion messages over, so as a minor optimization
 		// refresh the cache when a peer connects.
 		self.check_refresh_async_receive_offer_cache(false);
+		self.flow.set_peers(self.get_peers_for_blinded_path());
 		res
 	}
 

lightning/src/offers/flow.rs

@@ -61,6 +61,7 @@ use crate::sign::{EntropySource, NodeSigner, ReceiveAuthKey};
 
 use crate::offers::static_invoice::{StaticInvoice, StaticInvoiceBuilder};
 use crate::sync::{Mutex, RwLock};
+use crate::types::features::InitFeatures;
 use crate::types::payment::{PaymentHash, PaymentSecret};
 use crate::util::logger::Logger;
 use crate::util::ser::Writeable;
@@ -100,6 +101,7 @@ where
 
 	pending_async_payments_messages: Mutex<Vec<(AsyncPaymentsMessage, MessageSendInstructions)>>,
 	async_receive_offer_cache: Mutex<AsyncReceiveOfferCache>,
+	peers_cache: Mutex<Vec<MessageForwardNode>>,
 
 	#[cfg(feature = "dnssec")]
 	pub(crate) hrn_resolver: OMNameResolver,
@@ -136,6 +138,7 @@ where
 
 			pending_offers_messages: Mutex::new(Vec::new()),
 			pending_async_payments_messages: Mutex::new(Vec::new()),
+			peers_cache: Mutex::new(Vec::new()),
 
 			#[cfg(feature = "dnssec")]
 			hrn_resolver: OMNameResolver::new(current_timestamp, best_block.height),
@@ -1739,4 +1742,13 @@ where
 	pub fn writeable_async_receive_offer_cache(&self) -> Vec<u8> {
 		self.async_receive_offer_cache.encode()
 	}
+
+	/// Provides a set of connected peers of this node that can be used in [`BlindedMessagePath`]s
+	/// created by the [`OffersMessageFlow`].
+	///
+	/// All provided peers MUST advertise support for onion messages in their [`InitFeatures`].
+	pub fn set_peers(&self, mut peers: Vec<MessageForwardNode>) {
+		let mut peers_cache = self.peers_cache.lock().unwrap();
+		core::mem::swap(&mut *peers_cache, &mut peers);
+	}
 }