Move peer persistence onto async KV storage

Persist peer store updates through async KVStore operations. The
synchronous node APIs keep bridging at their runtime boundary while
async event handling awaits peer persistence directly.
Co-Authored-By: HAL 9000

Author: tnull

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();

src/event.rs

@@ -1524,36 +1524,38 @@ where
 },
 };
 
-let network_graph = self.network_graph.read_only();
-let channels =
-self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
-ifletSome(pending_channel) =
- channels.into_iter().find(|c| c.channel_id == channel_id)
-{
-if !pending_channel.is_outbound
- && self.peer_store.get_peer(&counterparty_node_id).is_none()
-{
-ifletSome(address) = network_graph
-.nodes()
-.get(&NodeId::from_pubkey(&counterparty_node_id))
-.and_then(|node_info| node_info.announcement_info.as_ref())
-.and_then(|ann_info| ann_info.addresses().first())
-{
-let peer = PeerInfo{
-node_id: counterparty_node_id,
-address: address.clone(),
-};
-
-self.peer_store.add_peer(peer).unwrap_or_else(|e| {
-log_error!(
-self.logger,
-"Failed to add peer {} to peer store: {}",
- counterparty_node_id,
- e
-);
-});
-}
-}
+let peer_to_store = {
+let network_graph = self.network_graph.read_only();
+let channels =
+self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+ channels
+.into_iter()
+.find(|c| c.channel_id == channel_id)
+.filter(|pending_channel| {
+ !pending_channel.is_outbound
+ && self.peer_store.get_peer(&counterparty_node_id).is_none()
+})
+.and_then(|_| {
+ network_graph
+.nodes()
+.get(&NodeId::from_pubkey(&counterparty_node_id))
+.and_then(|node_info| node_info.announcement_info.as_ref())
+.and_then(|ann_info| ann_info.addresses().first())
+.map(|address| PeerInfo{
+node_id: counterparty_node_id,
+address: address.clone(),
+})
+})
+};
+ifletSome(peer) = peer_to_store {
+self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
+log_error!(
+self.logger,
+"Failed to add peer {} to peer store: {}",
+ counterparty_node_id,
+ e
+);
+});
 }
 },
 LdkEvent::ChannelReady{

src/lib.rs

@@ -1121,7 +1121,7 @@ impl Node {
 log_info!(self.logger,"Connected to peer {}@{}. ", peer_info.node_id, peer_info.address);
 
 if persist {
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 }
 
 Ok(())
@@ -1138,7 +1138,7 @@ impl Node {
 
 log_info!(self.logger,"Disconnecting peer {}..", counterparty_node_id);
 
-matchself.peer_store.remove_peer(&counterparty_node_id){
+matchself.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id)){
 Ok(()) => {},
 Err(e) => {
 log_error!(self.logger,"Failed to remove peer {}: {}", counterparty_node_id, e)
@@ -1255,7 +1255,7 @@ impl Node {
  zero_reserve_string,
  peer_info.node_id
 );
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 Ok(UserChannelId(user_channel_id))
 },
 Err(e) => {
@@ -1861,7 +1861,7 @@ impl Node {
 
 // Check if this was the last open channel, if so, forget the peer.
 if open_channels.len() == 1{
-self.peer_store.remove_peer(&counterparty_node_id)?;
+self.runtime.block_on(self.peer_store.remove_peer(&counterparty_node_id))?;
 }
 }
 

src/payment/bolt11.rs

@@ -242,7 +242,7 @@ impl Bolt11Payment {
 self.payment_store.insert(payment)?;
 
 // Persist LSP peer to make sure we reconnect on restart.
-self.peer_store.add_peer(peer_info)?;
+self.runtime.block_on(self.peer_store.add_peer(peer_info))?;
 
 Ok(invoice)
 }

src/peer_store.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, RwLock};
 
 use bitcoin::secp256k1::PublicKey;
 use lightning::impl_writeable_tlv_based;
-use lightning::util::persist::KVStoreSync;
+use lightning::util::persist::KVStore;
 use lightning::util::ser::{Readable,ReadableArgs,Writeable,Writer};
 
 usecrate::io::{
@@ -27,6 +27,7 @@ where
 L::Target:LdkLogger,
 {
 peers:RwLock<HashMap<PublicKey,PeerInfo>>,
+mutation_lock: tokio::sync::Mutex<()>,
 kv_store:Arc<DynStore>,
 logger:L,
 }
@@ -37,44 +38,60 @@ where
 {
 pub(crate)fnnew(kv_store:Arc<DynStore>,logger:L) -> Self{
 let peers = RwLock::new(HashMap::new());
-Self{ peers, kv_store, logger }
+let mutation_lock = tokio::sync::Mutex::new(());
+Self{ peers, mutation_lock, kv_store, logger }
 }
 
-pub(crate)fnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
-if locked_peers.contains_key(&peer_info.node_id){
-returnOk(());
-}
-
- locked_peers.insert(peer_info.node_id, peer_info);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnadd_peer(&self,peer_info:PeerInfo) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+if locked_peers.contains_key(&peer_info.node_id){
+returnOk(());
+}
+ locked_peers.insert(peer_info.node_id, peer_info);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
-pub(crate)fnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
-letmut locked_peers = self.peers.write().expect("lock");
-
- locked_peers.remove(node_id);
-self.persist_peers(&*locked_peers)
+pub(crate)asyncfnremove_peer(&self,node_id:&PublicKey) -> Result<(),Error>{
+let _guard = self.mutation_lock.lock().await;
+let data = {
+letmut locked_peers = self.peers.write().expect("lock");
+ locked_peers.remove(node_id);
+PeerStoreSerWrapper(&locked_peers).encode()
+};
+self.persist_peers(data).await
 }
 
+/// Returns the current in-memory peer set.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnlist_peers(&self) -> Vec<PeerInfo>{
 self.peers.read().expect("lock").values().cloned().collect()
 }
 
+/// Returns the current in-memory peer info for `node_id`.
+///
+/// The async mutation lock serializes `add_peer` and `remove_peer`, but this synchronous
+/// reader cannot wait on it. Until peer-store reads are async, callers may observe peer
+/// changes that are still being persisted.
 pub(crate)fnget_peer(&self,node_id:&PublicKey) -> Option<PeerInfo>{
 self.peers.read().expect("lock").get(node_id).cloned()
 }
 
-fnpersist_peers(&self,locked_peers:&HashMap<PublicKey,PeerInfo>) -> Result<(),Error>{
-let data = PeerStoreSerWrapper(&*locked_peers).encode();
-KVStoreSync::write(
+asyncfnpersist_peers(&self,data:Vec<u8>) -> Result<(),Error>{
+KVStore::write(
 &*self.kv_store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
  data,
 )
+.await
 .map_err(|e| {
 log_error!(
 self.logger,
@@ -101,7 +118,8 @@ where
 let(kv_store, logger) = args;
 let read_peers:PeerStoreDeserWrapper = Readable::read(reader)?;
 let peers:RwLock<HashMap<PublicKey,PeerInfo>> = RwLock::new(read_peers.0);
-Ok(Self{ peers, kv_store, logger })
+let mutation_lock = tokio::sync::Mutex::new(());
+Ok(Self{ peers, mutation_lock, kv_store, logger })
 }
 }
 
@@ -158,8 +176,8 @@ mod tests {
 usecrate::io::test_utils::InMemoryStore;
 usecrate::types::DynStoreWrapper;
 
-#[test]
-fnpeer_info_persistence(){
+#[tokio::test]
+asyncfnpeer_info_persistence(){
 let store:Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 let logger = Arc::new(TestLogger::new());
 let peer_store = PeerStore::new(Arc::clone(&store),Arc::clone(&logger));
@@ -170,22 +188,24 @@ mod tests {
 .unwrap();
 let address = SocketAddress::from_str("127.0.0.1:9738").unwrap();
 let expected_peer_info = PeerInfo{ node_id, address };
-assert!(KVStoreSync::read(
+assert!(KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .is_err());
- peer_store.add_peer(expected_peer_info.clone()).unwrap();
+ peer_store.add_peer(expected_peer_info.clone()).await.unwrap();
 
 // Check we can read back what we persisted.
-let persisted_bytes = KVStoreSync::read(
+let persisted_bytes = KVStore::read(
 &*store,
 PEER_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 PEER_INFO_PERSISTENCE_KEY,
 )
+.await
 .unwrap();
 let deser_peer_store =
 PeerStore::read(&mut&persisted_bytes[..],(Arc::clone(&store), logger)).unwrap();