Handle internal transfers completed after shutdown

Currently we only process setting `TxMetadata` for internal
transfers if they complete in-line while the app is open and
running the rebalance logic. If, however, an internal transfer is
initiated but then does not complete the metadata is lost and
instead our transaction list includes a LN payment received and no
information about the trusted transaction at all.

Instead, here, we track enough information in
`TxType::PendingRebalance` to match the trusted transfer with an
LN transaction and then do so in `list_transactions`, updating
metadata as appropriate if we find a match.

We handle upgrades from previous versions of Orange gracefully,
though I'm not sure if we really need to do that yet.

Author: Matt Corallo

graduated-rebalancer/src/lib.rs

@@ -12,6 +12,7 @@ use bitcoin_payment_instructions::PaymentMethod;
 use lightning::bitcoin::hashes::Hash;
 use lightning::bitcoin::hex::DisplayHex;
 use lightning::bitcoin::OutPoint;
+use lightning::types::payment::PaymentHash;
 use lightning::util::logger::Logger;
 use lightning::{log_debug, log_error, log_info};
 use lightning_invoice::Bolt11Invoice;
@@ -159,6 +160,12 @@ pub enum RebalancerEvent {
 		trigger_id: [u8; 32],
 		/// Trusted wallet payment ID for the rebalance
 		trusted_rebalance_payment_id: [u8; 32],
+		/// The [`PaymentHash`] of this rebalance payment.
+		///
+		/// Note that if you're using LDK only we have the information required to make a
+		/// payment for this hash, meaning that any payments claimable by our lightning
+		/// wallet are related to this rebalance.
+		payment_hash: PaymentHash,
 		/// Amount being rebalanced in millisatoshis
 		amount_msat: u64,
 	},
@@ -170,6 +177,12 @@ pub enum RebalancerEvent {
 		trusted_rebalance_payment_id: [u8; 32],
 		/// Lightning payment ID for the rebalance
 		ln_rebalance_payment_id: [u8; 32],
+		/// The [`PaymentHash`] of this rebalance payment.
+		///
+		/// Note that if you're using LDK only we have the information required to make a
+		/// payment for this hash, meaning that any payments claimable by our lightning
+		/// wallet are related to this rebalance.
+		payment_hash: PaymentHash,
 		/// Amount rebalanced in millisatoshis
 		amount_msat: u64,
 		/// Total fee paid in millisatoshis
@@ -281,6 +294,7 @@ where
 						.handle_event(RebalancerEvent::RebalanceInitiated {
 							trigger_id: params.id,
 							trusted_rebalance_payment_id: rebalance_id,
+							payment_hash: PaymentHash(expected_hash.to_byte_array()),
 							amount_msat: transfer_amt.milli_sats(),
 						})
 						.await;
@@ -322,6 +336,7 @@ where
 							trusted_rebalance_payment_id: rebalance_id,
 							ln_rebalance_payment_id: ln_payment.id,
 							amount_msat: transfer_amt.milli_sats(),
+							payment_hash: PaymentHash(expected_hash.to_byte_array()),
 							fee_msat: ln_payment.fee_paid_msat.unwrap_or_default()
 								+ trusted_payment.fee_paid_msat.unwrap_or_default(),
 						})

orange-sdk/src/lib.rs

@@ -680,6 +680,15 @@ impl Wallet {
 			transaction: Option<Transaction>,
 		}
 
+		let mut completed_internal_transfers = HashMap::new();
+		#[derive(Debug)]
+		struct CompletedInternalTransfer {
+			trusted_transfer_id: [u8; 32],
+			payment_triggering_transfer: PaymentId,
+			time: Duration,
+			ln_transfer_id: Option<[u8; 32]>,
+		}
+
 		for payment in trusted_payments {
 			if let Some(tx_metadata) = tx_metadata.get(&PaymentId::Trusted(payment.id)) {
 				match &tx_metadata.ty {
@@ -732,7 +741,32 @@ impl Wallet {
 							time_since_epoch: tx_metadata.time,
 						});
 					},
-					TxType::PendingRebalance { .. } => {
+					TxType::PendingRebalance {
+						trusted_payment,
+						payment_triggering_transfer,
+						payment_hash,
+					} => {
+						if let Some(trusted_id) = trusted_payment {
+							debug_assert_eq!(*trusted_id, payment.id);
+						}
+						if payment.status == TxStatus::Completed {
+							if trusted_payment.is_some()
+								&& payment_triggering_transfer.is_some()
+								&& payment_hash.is_some()
+							{
+								let old_val = completed_internal_transfers.insert(
+									payment_hash.unwrap(),
+									CompletedInternalTransfer {
+										trusted_transfer_id: trusted_payment.unwrap(),
+										payment_triggering_transfer: payment_triggering_transfer
+											.unwrap(),
+										time: payment.time_since_epoch,
+										ln_transfer_id: None,
+									},
+								);
+								debug_assert!(old_val.is_none());
+							}
+						}
 						// Pending rebalances are not shown in the transaction list.
 						continue;
 					},
@@ -880,15 +914,63 @@ impl Wallet {
 					// failed rebalances.
 					continue;
 				}
-				res.push(Transaction {
-					id: PaymentId::SelfCustodial(payment.id.0),
-					status,
-					outbound: payment.direction == PaymentDirection::Outbound,
-					amount: payment.amount_msat.map(|a| Amount::from_milli_sats(a).unwrap()),
-					fee,
-					payment_type: (&payment).into(),
-					time_since_epoch: Duration::from_secs(payment.latest_update_timestamp),
-				})
+
+				let payment_hash = match payment.kind {
+					PaymentKind::Onchain { .. } => None,
+					PaymentKind::Bolt11 { hash, .. } => Some(hash),
+					PaymentKind::Bolt11Jit { hash, .. } => Some(hash),
+					PaymentKind::Bolt12Offer { hash, .. } => hash,
+					PaymentKind::Bolt12Refund { hash, .. } => hash,
+					PaymentKind::Spontaneous { hash, .. } => Some(hash),
+				};
+
+				if let Some(info) =
+					payment_hash.map(|hash| completed_internal_transfers.get_mut(&hash)).flatten()
+				{
+					info.ln_transfer_id = Some(payment.id.0);
+				} else {
+					res.push(Transaction {
+						id: PaymentId::SelfCustodial(payment.id.0),
+						status,
+						outbound: payment.direction == PaymentDirection::Outbound,
+						amount: payment.amount_msat.map(|a| Amount::from_milli_sats(a).unwrap()),
+						fee,
+						payment_type: (&payment).into(),
+						time_since_epoch: Duration::from_secs(payment.latest_update_timestamp),
+					})
+				}
+			}
+		}
+
+		std::mem::drop(tx_metadata);
+		for (_, info) in completed_internal_transfers {
+			debug_assert!(info.ln_transfer_id.is_some());
+			if let Some(lightning_payment) = info.ln_transfer_id {
+				log_info!(
+					self.inner.logger,
+					"Setting metadata for background-completed internal transfer with from trusted transaction {:?} to LN transaction {:?} triggered by transaction {}",
+					info.trusted_transfer_id,
+					lightning_payment,
+					info.payment_triggering_transfer
+				);
+				let metadata = TxMetadata {
+					ty: TxType::TrustedToLightning {
+						trusted_payment: info.trusted_transfer_id,
+						lightning_payment,
+						payment_triggering_transfer: info.payment_triggering_transfer,
+					},
+					time: info.time,
+				};
+				self.inner
+					.tx_metadata
+					.set_tx_caused_rebalance(&info.payment_triggering_transfer)
+					.expect("Failed to write metadata for rebalance transaction");
+				self.inner
+					.tx_metadata
+					.upsert(PaymentId::Trusted(info.trusted_transfer_id), metadata);
+				self.inner
+					.tx_metadata
+					.insert(PaymentId::SelfCustodial(lightning_payment), metadata);
 			}
 		}
 

orange-sdk/src/rebalancer.rs

@@ -289,9 +289,14 @@ impl graduated_rebalancer::EventHandler for OrangeRebalanceEventHandler {
 					trigger_id,
 					trusted_rebalance_payment_id,
 					amount_msat,
+					payment_hash,
 				} => {
 					let metadata = TxMetadata {
-						ty: TxType::PendingRebalance {},
+						ty: TxType::PendingRebalance {
+							payment_triggering_transfer: Some(PaymentId::Trusted(trigger_id)),
+							trusted_payment: Some(trusted_rebalance_payment_id),
+							payment_hash: Some(payment_hash),
+						},
 						time: SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(),
 					};
 					self.tx_metadata
@@ -312,6 +317,7 @@ impl graduated_rebalancer::EventHandler for OrangeRebalanceEventHandler {
 					trigger_id,
 					trusted_rebalance_payment_id: rebalance_id,
 					ln_rebalance_payment_id: lightning_id,
+					payment_hash: _,
 					amount_msat,
 					fee_msat,
 				} => {

orange-sdk/src/store.rs

@@ -18,7 +18,7 @@ use ldk_node::bitcoin::Txid;
 use ldk_node::bitcoin::hex::{DisplayHex, FromHex};
 use ldk_node::lightning::io;
 use ldk_node::lightning::ln::msgs::DecodeError;
-use ldk_node::lightning::types::payment::PaymentPreimage;
+use ldk_node::lightning::types::payment::{PaymentHash, PaymentPreimage};
 use ldk_node::lightning::util::persist::{KVStore, KVStoreSync};
 use ldk_node::lightning::util::ser::{Readable, Writeable, Writer};
 use ldk_node::lightning::{impl_writeable_tlv_based, impl_writeable_tlv_based_enum};
@@ -254,14 +254,21 @@ pub(crate) enum TxType {
 	Payment {
 		ty: PaymentType,
 	},
-	PendingRebalance {},
+	PendingRebalance {
+		// Note that while all of these fields are `Option`al, they are always
+		// filled in by any released version of Orange. They were added after
+		// some initial beta testing, however.
+		trusted_payment: Option<[u8; 32]>,
+		payment_triggering_transfer: Option<PaymentId>,
+		payment_hash: Option<PaymentHash>,
+	},
 }
 
 impl TxType {
 	pub(crate) fn is_rebalance(&self) -> bool {
 		matches!(
 			self,
-			TxType::PendingRebalance {}
+			TxType::PendingRebalance { .. }
 				| TxType::TrustedToLightning { .. }
 				| TxType::OnchainToLightning { .. }
 		)
@@ -280,7 +287,11 @@ impl_writeable_tlv_based_enum!(TxType,
 	},
 	(2, PaymentTriggeringTransferLightning) => { (0, ty, required), },
 	(3, Payment) => { (0, ty, required), },
-	(4, PendingRebalance) => {},
+	(4, PendingRebalance) => {
+		(1, trusted_payment, option),
+		(3, payment_triggering_transfer, option),
+		(5, payment_hash, option),
+	},
 );
 
 #[derive(Debug, Copy, Clone)]