ln: persist failure_reason with HTLCFailureReason

Author: carlaKC

lightning/src/ln/onion_utils.rs

@@ -22,7 +22,9 @@ use crate::types::features::{ChannelFeatures, NodeFeatures};
 use crate::types::payment::{PaymentHash, PaymentPreimage};
 use crate::util::errors::{self, APIError};
 use crate::util::logger::Logger;
-use crate::util::ser::{LengthCalculatingWriter, Readable, ReadableArgs, Writeable, Writer};
+use crate::util::ser::{
+	LengthCalculatingWriter, Readable, ReadableArgs, RequiredWrapper, Writeable, Writer,
+};
 
 use bitcoin::hashes::cmp::fixed_time_eq;
 use bitcoin::hashes::hmac::{Hmac, HmacEngine};
@@ -1608,6 +1610,49 @@ impl Into<LocalHTLCFailureReason> for u16 {
 	}
 }
 
+impl_writeable_tlv_based_enum!(LocalHTLCFailureReason,
+	(0, TemporaryNodeFailure) => {},
+	(2, PermanentNodeFailure) => {},
+	(4, RequiredNodeFeature) => {},
+	(6, InvalidOnionVersion) => {},
+	(8, InvalidOnionHMAC) => {},
+	(10, InvalidOnionKey) => {},
+	(12, TemporaryChannelFailure) => {},
+	(14, PermanentChannelFailure) => {},
+	(16, RequiredChannelFeature) => {},
+	(18, UnknownNextPeer) => {},
+	(20, AmountBelowMinimum) => {},
+	(22, FeeInsufficient) => {},
+	(24, IncorrectCLTVExpiry) => {},
+	(26, CLTVExpiryTooSoon) => {},
+	(28, IncorrectPaymentDetails) => {},
+	(30, FinalIncorrectCLTVExpiry) => {},
+	(32, FinalIncorrectHTLCAmount) => {},
+	(34, ChannelDisabled) => {},
+	(36, CLTVExpiryTooFar) => {},
+	(38, InvalidOnionPayload) => {},
+	(40, MPPTimeout) => {},
+	(42, InvalidOnionBlinding) => {},
+	(44, InvalidTrampolineForward) => {},
+	(46, PaymentClaimBuffer) => {},
+	(48, DustLimitHolder) => {},
+	(50, DustLimitCounterparty) => {},
+	(52, FeeSpikeBuffer) => {},
+	(54, DroppedPending) => {},
+	(56, PrivateChannelForward) => {},
+	(58, RealSCIDForward) => {},
+	(60, ChannelNotReady) => {},
+	(62, InvalidKeysendPreimage) => {},
+	(64, InvalidTrampolinePayload) => {},
+	(66, PaymentSecretRequired) => {},
+	(68, ForwardExpiryBuffer) => {},
+	(70, OutgoingCLTVTooSoon) => {},
+	(72, ChannelClosed) => {},
+	(74, UnknownFailureCode) => {
+		(0, code, required),
+	}
+);
+
 #[derive(Clone)] // See Channel::revoke_and_ack for why, tl;dr: Rust bug
 #[cfg_attr(test, derive(PartialEq))]
 pub(super) struct HTLCFailReason(HTLCFailReasonRepr);
@@ -1616,14 +1661,14 @@ pub(super) struct HTLCFailReason(HTLCFailReasonRepr);
 #[cfg_attr(test, derive(PartialEq))]
 enum HTLCFailReasonRepr {
 	LightningError { err: msgs::OnionErrorPacket },
-	Reason { failure_code: u16, data: Vec<u8> },
+	Reason { data: Vec<u8>, reason: LocalHTLCFailureReason },
 }
 
 impl core::fmt::Debug for HTLCFailReason {
 	fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
 		match self.0 {
-			HTLCFailReasonRepr::Reason { ref failure_code, .. } => {
-				write!(f, "HTLC error code {}", failure_code)
+			HTLCFailReasonRepr::Reason { ref reason, .. } => {
+				write!(f, "HTLC error code {}", reason.failure_code())
 			},
 			HTLCFailReasonRepr::LightningError { .. } => {
 				write!(f, "pre-built LightningError")
@@ -1655,8 +1700,19 @@ impl_writeable_tlv_based_enum!(HTLCFailReasonRepr,
 		(_unused, err, (static_value, msgs::OnionErrorPacket { data: data.ok_or(DecodeError::InvalidValue)? })),
 	},
 	(1, Reason) => {
-		(0, failure_code, required),
+		(0, _failure_code, (legacy, u16,
+			|r: &HTLCFailReasonRepr| Some(r.clone()) )),
 		(2, data, required_vec),
+		// failure_code was required, and is replaced by reason so any time we do not have a
+		// reason available failure_code will be Some so we can require reason.
+		(4, reason, (default_value,
+			if let Some(code) = _failure_code {
+				let failure_reason: LocalHTLCFailureReason = code.into();
+				RequiredWrapper::from(failure_reason)
+			} else {
+				reason
+			}
+		)),
 	},
 );
 
@@ -1728,7 +1784,7 @@ impl HTLCFailReason {
 			},
 		}
 
-		Self(HTLCFailReasonRepr::Reason { failure_code: failure_reason.failure_code(), data })
+		Self(HTLCFailReasonRepr::Reason { data, reason: failure_reason })
 	}
 
 	pub(super) fn from_failure_code(failure_reason: LocalHTLCFailureReason) -> Self {
@@ -1750,24 +1806,16 @@ impl HTLCFailReason {
 		&self, incoming_packet_shared_secret: &[u8; 32], secondary_shared_secret: &Option<[u8; 32]>,
 	) -> msgs::OnionErrorPacket {
 		match self.0 {
-			HTLCFailReasonRepr::Reason { ref failure_code, ref data } => {
-				let failure_code = *failure_code;
+			HTLCFailReasonRepr::Reason { ref data, ref reason } => {
 				if let Some(secondary_shared_secret) = secondary_shared_secret {
-					let mut packet = build_failure_packet(
-						secondary_shared_secret,
-						failure_code.into(),
-						&data[..],
-					);
+					let mut packet =
+						build_failure_packet(secondary_shared_secret, *reason, &data[..]);
 
 					crypt_failure_packet(incoming_packet_shared_secret, &mut packet);
 
 					packet
 				} else {
-					build_failure_packet(
-						incoming_packet_shared_secret,
-						failure_code.into(),
-						&data[..],
-					)
+					build_failure_packet(incoming_packet_shared_secret, *reason, &data[..])
 				}
 			},
 			HTLCFailReasonRepr::LightningError { ref err } => {
@@ -1791,7 +1839,7 @@ impl HTLCFailReason {
 				process_onion_failure(secp_ctx, logger, &htlc_source, err.clone())
 			},
 			#[allow(unused)]
-			HTLCFailReasonRepr::Reason { ref failure_code, ref data, .. } => {
+			HTLCFailReasonRepr::Reason { ref data, ref reason } => {
 				// we get a fail_malformed_htlc from the first hop
 				// TODO: We'd like to generate a NetworkUpdate for temporary
 				// failures here, but that would be insufficient as find_route
@@ -1804,7 +1852,7 @@ impl HTLCFailReason {
 						short_channel_id: Some(path.hops[0].short_channel_id),
 						failed_within_blinded_path: false,
 						#[cfg(any(test, feature = "_test_utils"))]
-						onion_error_code: Some(*failure_code),
+						onion_error_code: Some(reason.failure_code()),
 						#[cfg(any(test, feature = "_test_utils"))]
 						onion_error_data: Some(data.clone()),
 					}