Drop the DataStore::mutate_async wrapper

It only forwarded to mutate_with, so that method is now pub(crate) and
the callers that await fallible reads use it directly.

Written with the help of an AI tool.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: jkczyz

src/data_store.rs

@@ -451,7 +451,12 @@ where
 		self.mutate_with(id, |current| async move { Ok(f(current.as_ref())) }).await
 	}
 
-	async fn mutate_with<F, Fut>(&self, id: &SO::Id, f: F) -> Result<Option<SO>, Error>
+	/// Like [`Self::mutate`], but allows the transformation to await fallible reads.
+	///
+	/// The mutation lock remains held while `f` runs. This is useful when the new state must be
+	/// decided from an async read of another store without letting a concurrent writer invalidate
+	/// that decision. Callers must keep cross-store lock ordering consistent to avoid deadlocks.
+	pub(crate) async fn mutate_with<F, Fut>(&self, id: &SO::Id, f: F) -> Result<Option<SO>, Error>
 	where
 		F: FnOnce(Option<SO>) -> Fut,
 		Fut: Future<Output = Result<Option<SO>, Error>>,
@@ -470,19 +475,6 @@ where
 		Ok(Some(new_object))
 	}
 
-	/// Like [`Self::mutate`], but allows the transformation to await fallible reads.
-	///
-	/// The mutation lock remains held while `f` runs. This is useful when the new state must be
-	/// decided from an async read of another store without letting a concurrent writer invalidate
-	/// that decision. Callers must keep cross-store lock ordering consistent to avoid deadlocks.
-	pub(crate) async fn mutate_async<F, Fut>(&self, id: &SO::Id, f: F) -> Result<Option<SO>, Error>
-	where
-		F: FnOnce(Option<SO>) -> Fut,
-		Fut: Future<Output = Result<Option<SO>, Error>>,
-	{
-		self.mutate_with(id, f).await
-	}
-
 	/// Returns whether an object is stored under `id`.
 	pub(crate) async fn contains_key(&self, id: &SO::Id) -> Result<bool, Error> {
 		let _guard = self.mutation_lock.read().await;
@@ -1260,7 +1252,7 @@ mod tests {
 	}
 
 	#[tokio::test]
-	async fn mutate_async_awaits_fallible_reads() {
+	async fn mutate_with_awaits_fallible_reads() {
 		let store: Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
 		let logger = Arc::new(TestLogger::new());
 		let id = TestObjectId { id: [42u8; 4] };
@@ -1285,7 +1277,7 @@ mod tests {
 		);
 
 		let result = data_store
-			.mutate_async(&id, |existing| async move {
+			.mutate_with(&id, |existing| async move {
 				let mut updated = existing.unwrap();
 				updated.data = other_store.get(&other_id).await?.unwrap().data;
 				Ok(Some(updated))

src/wallet/payment_stores.rs

@@ -176,14 +176,14 @@ impl PaymentStoresGuard<'_> {
 	}
 
 	/// [`Self::mutate_pending_payment`] with a transformation that awaits fallible reads; see
-	/// [`DataStore::mutate_async`](crate::data_store::DataStore::mutate_async).
+	/// [`DataStore::mutate_with`](crate::data_store::DataStore::mutate_with).
 	pub(super) async fn mutate_pending_payment_async<F, Fut>(
 		&self, id: &PaymentId, f: F,
 	) -> Result<Option<PendingPaymentDetails>, Error>
 	where
 		F: FnOnce(Option<PendingPaymentDetails>) -> Fut,
 		Fut: Future<Output = Result<Option<PendingPaymentDetails>, Error>>,
 	{
-		self.stores.pending_payment_store.mutate_async(id, f).await
+		self.stores.pending_payment_store.mutate_with(id, f).await
 	}
 }