Make types available for fuzzing

Preparatory commit that exposes types that are related to onion failure
processing to the fuzzing targets.

Author: joostjager

lightning/src/ln/channelmanager.rs

@@ -409,27 +409,6 @@ pub enum BlindedFailure {
 	FromBlindedNode,
 }
 
-/// Tracks the inbound corresponding to an outbound HTLC
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub(crate) struct HTLCPreviousHopData {
-	// Note that this may be an outbound SCID alias for the associated channel.
-	short_channel_id: u64,
-	user_channel_id: Option<u128>,
-	htlc_id: u64,
-	incoming_packet_shared_secret: [u8; 32],
-	phantom_shared_secret: Option<[u8; 32]>,
-	blinded_failure: Option<BlindedFailure>,
-	channel_id: ChannelId,
-
-	// These fields are consumed by `claim_funds_from_hop()` when updating a force-closed backwards
-	// channel with a preimage provided by the forward channel.
-	outpoint: OutPoint,
-	counterparty_node_id: Option<PublicKey>,
-	/// Used to preserve our backwards channel by failing back in case an HTLC claim in the forward
-	/// channel remains unconfirmed for too long.
-	cltv_expiry: Option<u32>,
-}
-
 #[derive(PartialEq, Eq)]
 enum OnionPayload {
 	/// Indicates this incoming onion payload is for the purpose of paying an invoice.
@@ -674,21 +653,50 @@ impl_writeable_tlv_based_enum!(SentHTLCId,
 	},
 );
 
-
-/// Tracks the inbound corresponding to an outbound HTLC
-#[allow(clippy::derive_hash_xor_eq)] // Our Hash is faithful to the data, we just don't have SecretKey::hash
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum HTLCSource {
-	PreviousHopData(HTLCPreviousHopData),
-	OutboundRoute {
-		path: Path,
-		session_priv: SecretKey,
-		/// Technically we can recalculate this from the route, but we cache it here to avoid
-		/// doing a double-pass on route when we get a failure back
-		first_hop_htlc_msat: u64,
-		payment_id: PaymentId,
-	},
+mod fuzzy_channelmanager {
+	use super::*;
+
+	/// Tracks the inbound corresponding to an outbound HTLC
+	#[allow(clippy::derive_hash_xor_eq)] // Our Hash is faithful to the data, we just don't have SecretKey::hash
+	#[derive(Clone, Debug, PartialEq, Eq)]
+	pub enum HTLCSource {
+		PreviousHopData(HTLCPreviousHopData),
+		OutboundRoute {
+			path: Path,
+			session_priv: SecretKey,
+			/// Technically we can recalculate this from the route, but we cache it here to avoid
+			/// doing a double-pass on route when we get a failure back
+			first_hop_htlc_msat: u64,
+			payment_id: PaymentId,
+		},
+	}
+
+	/// Tracks the inbound corresponding to an outbound HTLC
+	#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+	pub struct HTLCPreviousHopData {
+		// Note that this may be an outbound SCID alias for the associated channel.
+		pub short_channel_id: u64,
+		pub user_channel_id: Option<u128>,
+		pub htlc_id: u64,
+		pub incoming_packet_shared_secret: [u8; 32],
+		pub phantom_shared_secret: Option<[u8; 32]>,
+		pub blinded_failure: Option<BlindedFailure>,
+		pub channel_id: ChannelId,
+
+		// These fields are consumed by `claim_funds_from_hop()` when updating a force-closed backwards
+		// channel with a preimage provided by the forward channel.
+		pub outpoint: OutPoint,
+		pub counterparty_node_id: Option<PublicKey>,
+		/// Used to preserve our backwards channel by failing back in case an HTLC claim in the forward
+		/// channel remains unconfirmed for too long.
+		pub cltv_expiry: Option<u32>,
+	}
 }
+#[cfg(fuzzing)]
+pub use self::fuzzy_channelmanager::*;
+#[cfg(not(fuzzing))]
+pub(crate) use self::fuzzy_channelmanager::*;
+
 #[allow(clippy::derive_hash_xor_eq)] // Our Hash is faithful to the data, we just don't have SecretKey::hash
 impl core::hash::Hash for HTLCSource {
 	fn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {

lightning/src/ln/mod.rs

@@ -51,6 +51,9 @@ pub use onion_utils::create_payment_onion;
 // without the node parameter being mut. This is incorrect, and thus newer rustcs will complain
 // about an unnecessary mut. Thus, we silence the unused_mut warning in two test modules below.
 
+#[cfg(fuzzing)]
+pub use onion_utils::process_onion_failure;
+
 #[cfg(test)]
 #[allow(unused_mut)]
 pub mod bolt11_payment_tests;

lightning/src/ln/msgs.rs

@@ -2241,6 +2241,13 @@ mod fuzzy_internal_msgs {
 		pub(crate) failuremsg: Vec<u8>,
 		pub(crate) pad: Vec<u8>,
 	}
+
+	#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+	pub struct OnionErrorPacket {
+		// This really should be a constant size slice, but the spec lets these things be up to 128KB?
+		// (TODO) We limit it in decode to much lower...
+		pub data: Vec<u8>,
+	}
 }
 #[cfg(fuzzing)]
 pub use self::fuzzy_internal_msgs::*;
@@ -2349,13 +2356,6 @@ impl Debug for TrampolineOnionPacket {
 	}
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub(crate) struct OnionErrorPacket {
-	// This really should be a constant size slice, but the spec lets these things be up to 128KB?
-	// (TODO) We limit it in decode to much lower...
-	pub(crate) data: Vec<u8>,
-}
-
 impl From<UpdateFailHTLC> for OnionErrorPacket {
 	fn from(msg: UpdateFailHTLC) -> Self {
 		OnionErrorPacket {

lightning/src/ln/onion_utils.rs

@@ -926,18 +926,26 @@ pub(super) fn build_failure_packet(
 	onion_error_packet
 }
 
-pub(crate) struct DecodedOnionFailure {
-	pub(crate) network_update: Option<NetworkUpdate>,
-	pub(crate) short_channel_id: Option<u64>,
-	pub(crate) payment_failed_permanently: bool,
-	pub(crate) failed_within_blinded_path: bool,
-	#[cfg(any(test, feature = "_test_utils"))]
-	pub(crate) onion_error_code: Option<u16>,
-	#[cfg(any(test, feature = "_test_utils"))]
-	pub(crate) onion_error_data: Option<Vec<u8>>,
+mod fuzzy_onion_utils {
+	use super::*;
+
+	pub struct DecodedOnionFailure {
+		pub(crate) network_update: Option<NetworkUpdate>,
+		pub(crate) short_channel_id: Option<u64>,
+		pub(crate) payment_failed_permanently: bool,
+		pub(crate) failed_within_blinded_path: bool,
+		#[cfg(any(test, feature = "_test_utils"))]
+		pub(crate) onion_error_code: Option<u16>,
+		#[cfg(any(test, feature = "_test_utils"))]
+		pub(crate) onion_error_data: Option<Vec<u8>>,
+	}
 }
+#[cfg(fuzzing)]
+pub use self::fuzzy_onion_utils::*;
+#[cfg(not(fuzzing))]
+pub(crate) use self::fuzzy_onion_utils::*;
 
-pub(super) fn process_onion_failure<T: secp256k1::Signing, L: Deref>(
+pub fn process_onion_failure<T: secp256k1::Signing, L: Deref>(
 	secp_ctx: &Secp256k1<T>, logger: &L, htlc_source: &HTLCSource,
 	encrypted_packet: OnionErrorPacket,
 ) -> DecodedOnionFailure