fixes and improvements post swaps PR merge

 * add payment_hash to Event::PaymentForwarded
 * fix handling of more than 1 HTLC output in a commitment
 * re-enable BTC-only payments in RGB channels
 * fix handling of RGB payment files when swapping (for channel balance) using inbound/outbound extension

Author: zoedberg

lightning/src/events/mod.rs

@@ -780,6 +780,8 @@ pub enum Event {
 		outbound_amount_forwarded_rgb: Option<u64>,
 		/// The rgb amount forwarded inbound.
 		inbound_amount_forwarded_rgb: Option<u64>,
+		/// The payment hash used for this payment.
+		payment_hash: PaymentHash,
 	},
 	/// Used to indicate that a channel with the given `channel_id` is being opened and pending
 	/// confirmation on-chain.
@@ -1061,6 +1063,7 @@ impl Writeable for Event {
 			&Event::PaymentForwarded {
 				fee_earned_msat, prev_channel_id, claim_from_onchain_tx,
 				next_channel_id, outbound_amount_forwarded_msat, outbound_amount_forwarded_rgb, inbound_amount_forwarded_rgb,
+				payment_hash,
 			} => {
 				7u8.write(writer)?;
 				write_tlv_fields!(writer, {
@@ -1071,6 +1074,7 @@ impl Writeable for Event {
 					(5, outbound_amount_forwarded_msat, option),
 					(6, outbound_amount_forwarded_rgb, option),
 					(7, inbound_amount_forwarded_rgb, option),
+					(8, payment_hash, required),
 				});
 			},
 			&Event::ChannelClosed { ref channel_id, ref user_channel_id, ref reason,
@@ -1377,6 +1381,7 @@ impl MaybeReadable for Event {
 					let mut outbound_amount_forwarded_msat = None;
 					let mut outbound_amount_forwarded_rgb = None;
 					let mut inbound_amount_forwarded_rgb = None;
+					let mut payment_hash = PaymentHash::new_zero();
 					read_tlv_fields!(reader, {
 						(0, fee_earned_msat, option),
 						(1, prev_channel_id, option),
@@ -1385,10 +1390,12 @@ impl MaybeReadable for Event {
 						(5, outbound_amount_forwarded_msat, option),
 						(6, outbound_amount_forwarded_rgb, option),
 						(7, inbound_amount_forwarded_rgb, option),
+						(8, payment_hash, required),
 					});
 					Ok(Some(Event::PaymentForwarded {
 						fee_earned_msat, prev_channel_id, claim_from_onchain_tx, next_channel_id,
 						outbound_amount_forwarded_msat, outbound_amount_forwarded_rgb, inbound_amount_forwarded_rgb,
+						payment_hash,
 					}))
 				};
 				f()

lightning/src/ln/channel.rs

@@ -3528,6 +3528,9 @@ impl<SP: Deref> Channel<SP> where
 				if let OutboundHTLCState::LocalAnnounced(_) = htlc.state {
 					log_trace!(logger, " ...promoting outbound LocalAnnounced {} to Committed", &htlc.payment_hash);
 					htlc.state = OutboundHTLCState::Committed;
+					if let Some(amount_rgb) = htlc.amount_rgb {
+						rgb_offered_htlc += amount_rgb;
+					}
 				}
 				if let &mut OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref mut outcome) = &mut htlc.state {
 					log_trace!(logger, " ...promoting outbound AwaitingRemoteRevokeToRemove {} to AwaitingRemovedRemoteRevoke", &htlc.payment_hash);
@@ -3537,14 +3540,13 @@ impl<SP: Deref> Channel<SP> where
 					htlc.state = OutboundHTLCState::AwaitingRemovedRemoteRevoke(reason);
 					require_commitment = true;
 				}
-				if let Some(amount_rgb) = htlc.amount_rgb {
-					rgb_offered_htlc += amount_rgb;
-				}
 			}
 		}
 		self.context.value_to_self_msat = (self.context.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
 		if self.context.is_colored() {
-			update_rgb_channel_amount_pending(&self.context.channel_id, rgb_offered_htlc, rgb_received_htlc, &self.context.ldk_data_dir);
+			if rgb_offered_htlc > 0 || rgb_received_htlc > 0 {
+				update_rgb_channel_amount_pending(&self.context.channel_id, rgb_offered_htlc, rgb_received_htlc, &self.context.ldk_data_dir);
+			}
 		}
 
 		if let Some((feerate, update_state)) = self.context.pending_update_fee {
@@ -5496,7 +5498,9 @@ impl<SP: Deref> Channel<SP> where
 			}
 		}
 		if self.context.is_colored() {
-			update_rgb_channel_amount_pending(&self.context.channel_id, 0, rgb_received_htlc, &self.context.ldk_data_dir);
+			if rgb_received_htlc > 0 {
+				update_rgb_channel_amount_pending(&self.context.channel_id, 0, rgb_received_htlc, &self.context.ldk_data_dir);
+			}
 		}
 		if let Some((feerate, update_state)) = self.context.pending_update_fee {
 			if update_state == FeeUpdateState::AwaitingRemoteRevokeToAnnounce {

lightning/src/ln/channelmanager.rs

@@ -48,7 +48,7 @@ use crate::ln::channel::{Channel, ChannelPhase, ChannelContext, ChannelError, Ch
 use crate::ln::features::{Bolt12InvoiceFeatures, ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
 #[cfg(any(feature = "_test_utils", test))]
 use crate::ln::features::Bolt11InvoiceFeatures;
-use crate::rgb_utils::{handle_funding, parse_rgb_payment_info};
+use crate::rgb_utils::{get_rgb_payment_info_path, handle_funding, parse_rgb_payment_info};
 use crate::routing::gossip::NetworkGraph;
 use crate::routing::router::{BlindedTail, DefaultRouter, InFlightHtlcs, Path, Payee, PaymentParameters, Route, RouteParameters, Router};
 use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters};
@@ -3472,11 +3472,10 @@ where
 		// The top-level caller should hold the total_consistency_lock read lock.
 		debug_assert!(self.total_consistency_lock.try_write().is_err());
 
-		let htlc_payment_hash = hex::encode(payment_hash.0);
-		let rgb_payment_info_hash_path = self.ldk_data_dir.join(htlc_payment_hash);
-		let path = if rgb_payment_info_hash_path.exists() {
-			let rgb_payment_info = parse_rgb_payment_info(&rgb_payment_info_hash_path);
-			if rgb_payment_info.override_route_amount {
+		let rgb_payment_info_hash_path_outbound = get_rgb_payment_info_path(payment_hash, &self.ldk_data_dir, false);
+		let path = if rgb_payment_info_hash_path_outbound.exists() {
+			let rgb_payment_info = parse_rgb_payment_info(&rgb_payment_info_hash_path_outbound);
+			if rgb_payment_info.swap_payment {
 				let mut path = path.clone();
 				for hop in &mut path.hops {
 					hop.rgb_amount = Some(rgb_payment_info.amount);
@@ -5810,6 +5809,7 @@ where
 									claimed_htlc_value.checked_sub(forwarded_htlc_value)
 								} else { None }
 							} else { None };
+							let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
 							Some(MonitorUpdateCompletionAction::EmitEventAndFreeOtherChannel {
 								event: events::Event::PaymentForwarded {
 									fee_earned_msat,
@@ -5819,6 +5819,7 @@ where
 									outbound_amount_forwarded_msat: forwarded_htlc_value_msat,
 									outbound_amount_forwarded_rgb,
 									inbound_amount_forwarded_rgb,
+									payment_hash,
 								},
 								downstream_counterparty_and_funding_outpoint: chan_to_release,
 							})

lightning/src/ln/mod.rs

@@ -88,6 +88,13 @@ impl core::fmt::Display for PaymentHash {
 	}
 }
 
+impl PaymentHash {
+	/// Create a payment hash consisting of all-zeros data (e.g. when uninitialized or a placeholder).
+	pub fn new_zero() -> Self {
+		Self([0; 32])
+	}
+}
+
 /// payment_preimage type, use to route payment between hop
 ///
 /// This is not exported to bindings users as we just use [u8; 32] directly

lightning/src/rgb_utils/mod.rs

@@ -58,6 +58,8 @@ pub const BITCOIN_NETWORK_FNAME: &str = "bitcoin_network";
 pub const ELECTRUM_URL_FNAME: &str = "electrum_url";
 /// Name of the file containing the wallet fingerprint
 pub const WALLET_FINGERPRINT_FNAME: &str = "wallet_fingerprint";
+const INBOUND_EXT: &str = "inbound";
+const OUTBOUND_EXT: &str = "outbound";
 
 /// RGB channel info
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -82,7 +84,7 @@ pub struct RgbPaymentInfo {
 	/// RGB remote amount
 	pub remote_rgb_amount: u64,
 	/// Whether the RGB amount in route should be overridden
-	pub override_route_amount: bool,
+	pub swap_payment: bool,
 	/// Whether the payment is inbound
 	pub inbound: bool,
 }
@@ -166,15 +168,29 @@ pub(crate) fn color_commitment<SP: Deref>(channel_context: &ChannelContext<SP>,
 		.assignments_type(&FieldName::from("beneficiary")).expect("valid assignment");
 
 	for htlc in commitment_tx.htlcs() {
+		if htlc.amount_rgb.unwrap_or(0) == 0 {
+            continue;
+        }
+		let htlc_amount_rgb = htlc.amount_rgb.expect("this HTLC has RGB assets");
+
 		let htlc_vout = htlc.transaction_output_index.unwrap();
 
+		let inbound = htlc.offered == counterparty;
+
 		let htlc_payment_hash = hex::encode(htlc.payment_hash.0);
 		let htlc_proxy_id = format!("{chan_id}{htlc_payment_hash}");
-		let rgb_payment_info_proxy_id_path = ldk_data_dir.join(htlc_proxy_id);
-
+		let mut rgb_payment_info_proxy_id_path = ldk_data_dir.join(htlc_proxy_id);
 		let rgb_payment_info_path = ldk_data_dir.join(htlc_payment_hash);
-		let mut rgb_payment_info_tmp_path = rgb_payment_info_path.clone();
-		rgb_payment_info_tmp_path.set_extension("pending");
+		let mut rgb_payment_info_path = rgb_payment_info_path.clone();
+		if inbound {
+			rgb_payment_info_proxy_id_path.set_extension(INBOUND_EXT);
+			rgb_payment_info_path.set_extension(INBOUND_EXT);
+		} else {
+			rgb_payment_info_proxy_id_path.set_extension(OUTBOUND_EXT);
+			rgb_payment_info_path.set_extension(OUTBOUND_EXT);
+		}
+		let rgb_payment_info_tmp_path = append_pending_extension(&rgb_payment_info_path);
+
 		if rgb_payment_info_tmp_path.exists() {
 			let mut rgb_payment_info = parse_rgb_payment_info(&rgb_payment_info_tmp_path);
 			rgb_payment_info.local_rgb_amount = rgb_info.local_rgb_amount;
@@ -189,19 +205,19 @@ pub(crate) fn color_commitment<SP: Deref>(channel_context: &ChannelContext<SP>,
 		} else {
 			let rgb_payment_info = RgbPaymentInfo {
 				contract_id: rgb_info.contract_id,
-				amount: htlc.amount_rgb.unwrap(),
+				amount: htlc_amount_rgb,
 				local_rgb_amount: rgb_info.local_rgb_amount,
 				remote_rgb_amount: rgb_info.remote_rgb_amount,
-				override_route_amount: false,
-				inbound: htlc.offered == counterparty,
+				swap_payment: false,
+				inbound,
 			};
 			let serialized_info = serde_json::to_string(&rgb_payment_info).expect("valid rgb payment info");
 			fs::write(rgb_payment_info_proxy_id_path, serialized_info.clone()).expect("able to write rgb payment info file");
 			fs::write(rgb_payment_info_path, serialized_info).expect("able to write rgb payment info file");
 			rgb_payment_info
 		};
 
-		if htlc.offered == counterparty {
+		if inbound {
 			rgb_received_htlc += rgb_payment_info.amount
 		} else {
 			rgb_offered_htlc += rgb_payment_info.amount
@@ -328,10 +344,10 @@ pub(crate) fn color_commitment<SP: Deref>(channel_context: &ChannelContext<SP>,
 
 /// Color HTLC transaction
 pub(crate) fn color_htlc(htlc_tx: &mut Transaction, htlc: &HTLCOutputInCommitment, ldk_data_dir: &Path) -> Result<(), ChannelError> {
-	let htlc_amount_rgb = htlc.amount_rgb.expect("this is a rgb channel");
-	if htlc_amount_rgb == 0 {
+	if htlc.amount_rgb.unwrap_or(0) == 0 {
 		return Ok(())
 	}
+	let htlc_amount_rgb = htlc.amount_rgb.expect("this HTLC has RGB assets");
 
 	htlc_tx.output.push(TxOut { value: 0, script_pubkey: Script::new_op_return(&[1]) });
 	let psbt = PartiallySignedTransaction::from_unsigned_tx(htlc_tx.clone()).expect("valid transaction");
@@ -511,8 +527,10 @@ pub(crate) fn color_closing(channel_id: &ChannelId, funding_outpoint: &OutPoint,
 }
 
 /// Get RgbPaymentInfo file path
-pub fn get_rgb_payment_info_path(payment_hash: &PaymentHash, ldk_data_dir: &Path) -> PathBuf {
-	ldk_data_dir.join(hex::encode(payment_hash.0))
+pub fn get_rgb_payment_info_path(payment_hash: &PaymentHash, ldk_data_dir: &Path, inbound: bool) -> PathBuf {
+	let mut path = ldk_data_dir.join(hex::encode(payment_hash.0));
+	path.set_extension(if inbound { INBOUND_EXT } else { OUTBOUND_EXT });
+	path
 }
 
 /// Parse RgbPaymentInfo
@@ -559,17 +577,22 @@ pub fn write_rgb_channel_info(path: &PathBuf, rgb_info: &RgbInfo) {
 	fs::write(path, serialized_info).expect("able to write")
 }
 
+fn append_pending_extension(path: &PathBuf) -> PathBuf {
+	let mut new_path = path.clone();
+	new_path.set_extension(format!("{}_pending", new_path.extension().unwrap().to_string_lossy()));
+	new_path
+}
+
 /// Write RGB payment info to file
-pub fn write_rgb_payment_info_file(ldk_data_dir: &Path, payment_hash: &PaymentHash, contract_id: ContractId, amount_rgb: u64, override_route_amount: bool, inbound: bool) {
-	let rgb_payment_info_path = get_rgb_payment_info_path(payment_hash, ldk_data_dir);
-	let mut rgb_payment_info_tmp_path = rgb_payment_info_path.clone();
-	rgb_payment_info_tmp_path.set_extension("pending");
+pub fn write_rgb_payment_info_file(ldk_data_dir: &Path, payment_hash: &PaymentHash, contract_id: ContractId, amount_rgb: u64, swap_payment: bool, inbound: bool) {
+	let rgb_payment_info_path = get_rgb_payment_info_path(payment_hash, ldk_data_dir, inbound);
+	let rgb_payment_info_tmp_path = append_pending_extension(&rgb_payment_info_path);
 	let rgb_payment_info = RgbPaymentInfo {
 		contract_id,
 		amount: amount_rgb,
 		local_rgb_amount: 0,
 		remote_rgb_amount: 0,
-		override_route_amount,
+		swap_payment,
 		inbound,
 	};
 	let serialized_info = serde_json::to_string(&rgb_payment_info).expect("valid rgb payment info");
@@ -716,12 +739,13 @@ pub(crate) fn update_rgb_channel_amount_pending(channel_id: &ChannelId, rgb_offe
 
 /// Whether the payment is colored
 pub(crate) fn is_payment_rgb(ldk_data_dir: &Path, payment_hash: &PaymentHash) -> bool {
-	ldk_data_dir.join(hex::encode(payment_hash.0)).exists()
+	get_rgb_payment_info_path(payment_hash, ldk_data_dir, false).exists() ||
+		get_rgb_payment_info_path(payment_hash, ldk_data_dir, true).exists()
 }
 
 /// Filter first_hops for contract_id
 pub(crate) fn filter_first_hops(ldk_data_dir: &Path, payment_hash: &PaymentHash, first_hops: &mut Vec<&ChannelDetails>) -> ContractId {
-	let rgb_payment_info_path = ldk_data_dir.join(hex::encode(payment_hash.0));
+	let rgb_payment_info_path = get_rgb_payment_info_path(payment_hash, ldk_data_dir, false);
 	let serialized_info = fs::read_to_string(rgb_payment_info_path).expect("valid rgb payment info file");
 	let rgb_payment_info: RgbPaymentInfo = serde_json::from_str(&serialized_info).expect("valid rgb payment info file");
 	let contract_id = rgb_payment_info.contract_id;