Fix documentation on onion message packet ControlTlvs

[rust-lightning] / lightning / src / ln / outbound_payment.rs

diff --git a/lightning/src/ln/outbound_payment.rs b/lightning/src/ln/outbound_payment.rs
index 45c723b852544c37af1a7eafb8f404914cf62c77..6e927aa95ab2deed2ef86ba451741a9514ca0a9f 100644 (file)
--- a/lightning/src/ln/outbound_payment.rs
+++ b/lightning/src/ln/outbound_payment.rs
@@ -17,7 +17,7 @@ use crate::sign::{EntropySource, NodeSigner, Recipient};
 use crate::events::{self, PaymentFailureReason};
 use crate::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::ln::channelmanager::{ChannelDetails, EventCompletionAction, HTLCSource, IDEMPOTENCY_TIMEOUT_TICKS, PaymentId};
-use crate::ln::onion_utils::HTLCFailReason;
+use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
 use crate::routing::router::{InFlightHtlcs, Path, PaymentParameters, Route, RouteParameters, Router};
 use crate::util::errors::APIError;
 use crate::util::logger::Logger;
@@ -47,6 +47,7 @@ pub(crate) enum PendingOutboundPayment {
                payment_secret: Option<PaymentSecret>,
                payment_metadata: Option<Vec<u8>>,
                keysend_preimage: Option<PaymentPreimage>,
+               custom_tlvs: Vec<(u64, Vec<u8>)>,
                pending_amt_msat: u64,
                /// Used to track the fee paid. Only present if the payment was serialized on 0.0.103+.
                pending_fee_msat: Option<u64>,
@@ -510,7 +511,17 @@ impl RecipientOnionFields {
        pub(super) fn check_merge(&mut self, further_htlc_fields: &mut Self) -> Result<(), ()> {
                if self.payment_secret != further_htlc_fields.payment_secret { return Err(()); }
                if self.payment_metadata != further_htlc_fields.payment_metadata { return Err(()); }
-               // For custom TLVs we should just drop non-matching ones, but not reject the payment.
+
+               let tlvs = &mut self.custom_tlvs;
+               let further_tlvs = &mut further_htlc_fields.custom_tlvs;
+
+               let even_tlvs = tlvs.iter().filter(|(typ, _)| *typ % 2 == 0);
+               let further_even_tlvs = further_tlvs.iter().filter(|(typ, _)| *typ % 2 == 0);
+               if even_tlvs.ne(further_even_tlvs) { return Err(()) }
+
+               tlvs.retain(|tlv| further_tlvs.iter().any(|further_tlv| tlv == further_tlv));
+               further_tlvs.retain(|further_tlv| tlvs.iter().any(|tlv| tlv == further_tlv));
+
                Ok(())
        }
 }
@@ -804,7 +815,8 @@ impl OutboundPayments {
                                hash_map::Entry::Occupied(mut payment) => {
                                        let res = match payment.get() {
                                                PendingOutboundPayment::Retryable {
-                                                       total_msat, keysend_preimage, payment_secret, payment_metadata, pending_amt_msat, ..
+                                                       total_msat, keysend_preimage, payment_secret, payment_metadata,
+                                                       custom_tlvs, pending_amt_msat, ..
                                                } => {
                                                        let retry_amt_msat = route.get_total_amount();
                                                        if retry_amt_msat + *pending_amt_msat > *total_msat * (100 + RETRY_OVERFLOW_PERCENTAGE) / 100 {
@@ -815,7 +827,7 @@ impl OutboundPayments {
                                                        (*total_msat, RecipientOnionFields {
                                                                        payment_secret: *payment_secret,
                                                                        payment_metadata: payment_metadata.clone(),
-                                                                       custom_tlvs: Vec::new(),
+                                                                       custom_tlvs: custom_tlvs.clone(),
                                                                }, *keysend_preimage)
                                                },
                                                PendingOutboundPayment::Legacy { .. } => {
@@ -1014,6 +1026,7 @@ impl OutboundPayments {
                                        payment_secret: recipient_onion.payment_secret,
                                        payment_metadata: recipient_onion.payment_metadata,
                                        keysend_preimage,
+                                       custom_tlvs: recipient_onion.custom_tlvs,
                                        starting_block_height: best_block_height,
                                        total_msat: route.get_total_amount(),
                                });
@@ -1164,7 +1177,7 @@ impl OutboundPayments {
 
        pub(super) fn claim_htlc<L: Deref>(
                &self, payment_id: PaymentId, payment_preimage: PaymentPreimage, session_priv: SecretKey,
-               path: Path, from_onchain: bool,
+               path: Path, from_onchain: bool, ev_completion_action: EventCompletionAction,
                pending_events: &Mutex<VecDeque<(events::Event, Option<EventCompletionAction>)>>,
                logger: &L,
        ) where L::Target: Logger {
@@ -1181,7 +1194,7 @@ impl OutboundPayments {
                                        payment_preimage,
                                        payment_hash,
                                        fee_paid_msat,
-                               }, None));
+                               }, Some(ev_completion_action.clone())));
                                payment.get_mut().mark_fulfilled();
                        }
 
@@ -1198,7 +1211,7 @@ impl OutboundPayments {
                                                payment_id,
                                                payment_hash,
                                                path,
-                                       }, None));
+                                       }, Some(ev_completion_action)));
                                }
                        }
                } else {
@@ -1280,9 +1293,12 @@ impl OutboundPayments {
                pending_events: &Mutex<VecDeque<(events::Event, Option<EventCompletionAction>)>>, logger: &L,
        ) -> bool where L::Target: Logger {
                #[cfg(test)]
-               let (network_update, short_channel_id, payment_retryable, onion_error_code, onion_error_data) = onion_error.decode_onion_failure(secp_ctx, logger, &source);
+               let DecodedOnionFailure {
+                       network_update, short_channel_id, payment_retryable, onion_error_code, onion_error_data
+               } = onion_error.decode_onion_failure(secp_ctx, logger, &source);
                #[cfg(not(test))]
-               let (network_update, short_channel_id, payment_retryable, _, _) = onion_error.decode_onion_failure(secp_ctx, logger, &source);
+               let DecodedOnionFailure { network_update, short_channel_id, payment_retryable } =
+                       onion_error.decode_onion_failure(secp_ctx, logger, &source);
 
                let payment_is_probe = payment_is_probe(payment_hash, &payment_id, probing_cookie_secret);
                let mut session_priv_bytes = [0; 32];
@@ -1463,6 +1479,7 @@ impl_writeable_tlv_based_enum_upgradable!(PendingOutboundPayment,
                (6, total_msat, required),
                (7, payment_metadata, option),
                (8, pending_amt_msat, required),
+               (9, custom_tlvs, optional_vec),
                (10, starting_block_height, required),
                (not_written, retry_strategy, (static_value, None)),
                (not_written, attempts, (static_value, PaymentAttempts::new())),