make minimum channel reserve configurable (#1)

Add configurable min_their_channel_reserve_satoshis field to
ChannelHandshakeConfig, allowing users to set the minimum channel
reserve value.

Special case: When set to 0, the dust limit check is bypassed.
This enables LSP use cases where clients are able to fully withdraw
their funds from the channel without closing it. For non-zero values
below the dust limit, validation still enforces the dust limit.

Replaces hardcoded MIN_THEIR_CHAN_RESERVE_SATOSHIS constant with
configurable value while maintaining backward compatibility. Default
remains 1000 sats to preserve existing behavior.

Author: amackillop

lightning-liquidity/src/lsps4/htlc_store.rs

@@ -9,7 +9,7 @@ use lightning::util::ser::{Readable, Writeable};
 use lightning::{impl_writeable_tlv_based, log_error};
 use lightning::ln::channelmanager::InterceptId;
 use lightning::util::logger::Logger;
-use lightning::util::persist::KVStore;
+use lightning::util::persist::KVStoreSync;
 use lightning_types::payment::PaymentHash;
 
 use bitcoin::secp256k1::PublicKey;
@@ -97,30 +97,30 @@ impl_writeable_tlv_based!(InterceptedHtlc, {
 });
 
 pub struct HTLCStore<L: Deref, KV: Deref + Clone>
-where L::Target: Logger, KV::Target: KVStore {
+where L::Target: Logger, KV::Target: KVStoreSync {
 	htlcs: Mutex<HashMap<InterceptId, InterceptedHtlc>>,
 	kv_store: KV,
 	logger: L
 }
 
 impl<L: Deref, KV: Deref + Clone> HTLCStore<L, KV>
-where L::Target: Logger, KV::Target: KVStore {
-	pub(crate) async fn new(
+where L::Target: Logger, KV::Target: KVStoreSync {
+	pub(crate) fn new(
 		kv_store: KV, logger: L,
 	) -> Result<Self, io::Error> {
 		let mut htlcs = Vec::new();
 
 		let stored_keys = kv_store.list(
 			INTERCEPTED_HTLC_STORE_PERSISTENCE_PRIMARY_NAMESPACE,
 			INTERCEPTED_HTLC_STORE_PERSISTENCE_SECONDARY_NAMESPACE,
-		).await?;
+		)?;
 
 		for stored_key in stored_keys {
 			let data = kv_store.read(
 				INTERCEPTED_HTLC_STORE_PERSISTENCE_PRIMARY_NAMESPACE,
 				INTERCEPTED_HTLC_STORE_PERSISTENCE_SECONDARY_NAMESPACE,
 				&stored_key,
-			).await?;
+			)?;
 			let mut reader = Cursor::new(data);
 			let htlc = InterceptedHtlc::read(&mut reader).map_err(|e| {
 				log_error!(logger, "Failed to deserialize InterceptedHtlc: {}", e);
@@ -138,7 +138,7 @@ where L::Target: Logger, KV::Target: KVStore {
 		Ok(Self { htlcs, kv_store, logger })
 	}
 
-	pub(crate) async fn insert(&self, htlc: InterceptedHtlc) -> Result<bool, io::Error> {
+	pub(crate) fn insert(&self, htlc: InterceptedHtlc) -> Result<bool, io::Error> {
 		// Check if already exists
 		{
 			let locked_htlcs = self.htlcs.lock().unwrap();
@@ -147,22 +147,21 @@ where L::Target: Logger, KV::Target: KVStore {
 			}
 		}
 
-		// Persist first (outside the lock to avoid holding across await)
-		self.persist(&htlc).await?;
+		// Persist first (outside the lock)
+		self.persist(&htlc)?;
 
 		// Then insert into the map
 		let mut locked_htlcs = self.htlcs.lock().unwrap();
 		let updated = locked_htlcs.insert(htlc.id(), htlc).is_some();
 		Ok(updated)
 	}
 
-	pub(crate) async fn remove(&self, id: &InterceptId) -> Result<(), io::Error> {
+	pub(crate) fn remove(&self, id: &InterceptId) -> Result<(), io::Error> {
 		let removed = self.htlcs.lock().unwrap().remove(id).is_some();
 		if removed {
 			let store_key = utils::to_string(&id.0);
 			self.kv_store
 				.remove(INTERCEPTED_HTLC_STORE_PERSISTENCE_PRIMARY_NAMESPACE, INTERCEPTED_HTLC_STORE_PERSISTENCE_SECONDARY_NAMESPACE, &store_key, false)
-				.await
 				.map_err(|e| {
 					log_error!(
 						self.logger,
@@ -199,12 +198,11 @@ where L::Target: Logger, KV::Target: KVStore {
 		})
 	}
 
-	async fn persist(&self, htlc: &InterceptedHtlc) -> Result<(), io::Error> {
+	fn persist(&self, htlc: &InterceptedHtlc) -> Result<(), io::Error> {
 		let store_key = utils::to_string(&htlc.id().0);
 		let data = htlc.encode();
 		self.kv_store
 			.write(INTERCEPTED_HTLC_STORE_PERSISTENCE_PRIMARY_NAMESPACE, INTERCEPTED_HTLC_STORE_PERSISTENCE_SECONDARY_NAMESPACE, &store_key, data)
-			.await
 			.map_err(|e| {
 				log_error!(
 					self.logger,
@@ -217,7 +215,7 @@ where L::Target: Logger, KV::Target: KVStore {
 		Ok(())
 	}
 
-	pub async fn add_intercepted_htlc(
+	pub fn add_intercepted_htlc(
 		&self, intercept_id: InterceptId, requested_next_hop_scid: u64,
 		expected_outbound_amount_msat: u64, payment_hash: PaymentHash, next_node_id: PublicKey,
 	) -> Result<bool, io::Error> {
@@ -228,6 +226,6 @@ where L::Target: Logger, KV::Target: KVStore {
 			payment_hash,
 			next_node_id,
 		);
-		self.insert(htlc).await
+		self.insert(htlc)
 	}
 }

lightning-liquidity/src/lsps4/scid_store.rs

@@ -8,7 +8,7 @@
 use lightning::util::ser::{Readable, Writeable};
 use lightning::{impl_writeable_tlv_based, log_error};
 use lightning::util::logger::Logger;
-use lightning::util::persist::KVStore;
+use lightning::util::persist::KVStoreSync;
 
 use bitcoin::secp256k1::PublicKey;
 
@@ -62,31 +62,31 @@ impl_writeable_tlv_based!(ScidWithPeer, {
 });
 
 pub struct ScidStore<L: Deref, KV: Deref + Clone>
-where L::Target: Logger, KV::Target: KVStore {
+where L::Target: Logger, KV::Target: KVStoreSync {
 	peer_by_scid: RwLock<HashMap<u64, PublicKey>>,
 	scid_by_peer: RwLock<HashMap<PublicKey, u64>>,
 	kv_store: KV,
 	logger: L
 }
 
 impl<L: Deref, KV: Deref + Clone> ScidStore<L, KV>
-where L::Target: Logger, KV::Target: KVStore {
-	pub(crate) async fn new(
+where L::Target: Logger, KV::Target: KVStoreSync {
+	pub(crate) fn new(
 		kv_store: KV, logger: L,
 	) -> Result<Self, io::Error> {
 		let mut scids = Vec::new();
 
 		let stored_keys = kv_store.list(
 			INTERCEPT_SCID_STORE_PERSISTENCE_PRIMARY_NAMESPACE,
 			INTERCEPT_SCID_STORE_PERSISTENCE_SECONDARY_NAMESPACE,
-		).await?;
+		)?;
 
 		for stored_key in stored_keys {
 			let data = kv_store.read(
 				INTERCEPT_SCID_STORE_PERSISTENCE_PRIMARY_NAMESPACE,
 				INTERCEPT_SCID_STORE_PERSISTENCE_SECONDARY_NAMESPACE,
 				&stored_key,
-			).await?;
+			)?;
 			let mut reader = Cursor::new(data);
 			let scid = ScidWithPeer::read(&mut reader).map_err(|e| {
 				log_error!(logger, "Failed to deserialize InterceptScid: {}", e);
@@ -107,19 +107,31 @@ where L::Target: Logger, KV::Target: KVStore {
 		Ok(Self { peer_by_scid, scid_by_peer, kv_store, logger })
 	}
 
-	pub(crate) async fn insert(&self, scid: ScidWithPeer) -> Result<bool, io::Error> {
-		// Persist first (outside the lock to avoid holding across await)
-		self.persist(&scid).await?;
+	pub(crate) fn insert(&self, scid: ScidWithPeer) -> Result<bool, io::Error> {
+		use lightning::log_info;
+		log_info!(self.logger, "[LSPS4 ScidStore] Inserting SCID {} for peer {}", scid.scid(), scid.peer_id());
+
+		// Persist first
+		self.persist(&scid)?;
 
 		// Then insert into the maps
 		let mut locked_peer_by_scid = self.peer_by_scid.write().unwrap();
 		let mut locked_scid_by_peer = self.scid_by_peer.write().unwrap();
 		let updated = locked_peer_by_scid.insert(scid.scid(), scid.peer_id().clone()).is_some();
 		locked_scid_by_peer.insert(scid.peer_id().clone(), scid.scid());
+
+		log_info!(
+			self.logger,
+			"[LSPS4 ScidStore] Successfully inserted SCID {} for peer {} (was_update: {})",
+			scid.scid(),
+			scid.peer_id(),
+			updated
+		);
+
 		Ok(updated)
 	}
 
-	pub(crate) async fn remove(&self, scid: u64) -> Result<(), io::Error> {
+	pub(crate) fn remove(&self, scid: u64) -> Result<(), io::Error> {
 		let mut locked_peer_by_scid = self.peer_by_scid.write().unwrap();
 		let mut locked_scid_by_peer = self.scid_by_peer.write().unwrap();
 
@@ -129,7 +141,6 @@ where L::Target: Logger, KV::Target: KVStore {
 			let store_key = utils::to_string(&scid.to_be_bytes());
 			self.kv_store
 				.remove(INTERCEPT_SCID_STORE_PERSISTENCE_PRIMARY_NAMESPACE, INTERCEPT_SCID_STORE_PERSISTENCE_SECONDARY_NAMESPACE, &store_key, false)
-				.await
 				.map_err(|e| {
 					log_error!(
 						self.logger,
@@ -143,12 +154,11 @@ where L::Target: Logger, KV::Target: KVStore {
 		Ok(())
 	}
 
-	async fn persist(&self, scid: &ScidWithPeer) -> Result<(), io::Error> {
+	fn persist(&self, scid: &ScidWithPeer) -> Result<(), io::Error> {
 		let store_key = scid.store_key();
 		let data = scid.encode();
 		self.kv_store
 			.write(INTERCEPT_SCID_STORE_PERSISTENCE_PRIMARY_NAMESPACE, INTERCEPT_SCID_STORE_PERSISTENCE_SECONDARY_NAMESPACE, &store_key, data)
-			.await
 			.map_err(|e| {
 				log_error!(
 					self.logger,
@@ -161,21 +171,37 @@ where L::Target: Logger, KV::Target: KVStore {
 		Ok(())
 	}
 
-	pub async fn add_intercepted_scid(
+	pub fn add_intercepted_scid(
 		&self, scid: u64, peer_id: PublicKey,
 	) -> Result<bool, io::Error> {
 		let scid = ScidWithPeer::new(
 			scid,
 			peer_id,
 		);
-		self.insert(scid).await
+		self.insert(scid)
 	}
 
 	pub fn get_peer(&self, scid: u64) -> Option<PublicKey> {
-		self.peer_by_scid.read().unwrap().get(&scid).cloned()
+		use lightning::log_debug;
+		let result = self.peer_by_scid.read().unwrap().get(&scid).cloned();
+		log_debug!(
+			self.logger,
+			"[LSPS4 ScidStore] get_peer({}) = {:?}",
+			scid,
+			result
+		);
+		result
 	}
 
 	pub fn get_scid(&self, peer_id: &PublicKey) -> Option<u64> {
-		self.scid_by_peer.read().unwrap().get(peer_id).cloned()
+		use lightning::log_debug;
+		let result = self.scid_by_peer.read().unwrap().get(peer_id).cloned();
+		log_debug!(
+			self.logger,
+			"[LSPS4 ScidStore] get_scid({}) = {:?}",
+			peer_id,
+			result
+		);
+		result
 	}
 }