f use a smaller offer

Signed-off-by: Vincenzo Palazzo <vincenzopalazzodev@gmail.com>

Author: vincenzopalazzo

lightning/src/ln/channelmanager.rs

@@ -13062,10 +13062,10 @@ where
 		} else {
 			builder
 		};
-		// Create a minimal offer for BLIP-42 contact exchange (just node_id, no description/paths)
-		// TODO: Create a better minimal offer with a single blinded path hop for privacy,
-		// while keeping the size small enough to fit in the onion packet.
-		let payer_offer = self.create_offer_builder()?.build()?;
+		// Create a minimal compact offer for BLIP-42 contact exchange.
+		// This uses derived metadata (for verification) but no blinded paths, making it small
+		// enough to fit in the onion packet (~70 bytes vs 300+ bytes with blinded paths).
+		let payer_offer = self.flow.create_compact_offer_builder(&*self.entropy_source)?.build()?;
 		let builder = builder.payer_offer(&payer_offer);
 
 		let invoice_request = builder.build_and_sign()?;

lightning/src/ln/offers_tests.rs

@@ -2659,27 +2659,27 @@ fn pay_offer_and_add_contacts_info_blip42() {
 	assert!(invoice_request.payer_offer().is_some());
 
 	let onion_message = bob.onion_messenger.next_onion_message_for_peer(alice_id).unwrap();
-	bob.onion_messenger.handle_onion_message(bob_id, &onion_message);
+	alice.onion_messenger.handle_onion_message(bob_id, &onion_message);
 
 	let (invoice, _reply_path) = extract_invoice(alice, &onion_message);
-	assert_eq!(invoice.amount_msats(), 10_000_000);
+	assert_eq!(invoice.amount_msats(), 5_000_000);
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 
-	route_bolt12_payment(bob, &[alice], &invoice);
-	expect_recent_payment!(bob, RecentPaymentDetails::Pending, payment_id);
+	route_bolt12_payment(alice, &[bob], &invoice);
+	expect_recent_payment!(alice, RecentPaymentDetails::Pending, payment_id);
 
-	let (_, alice_payment_preimage) = match get_event!(alice, Event::PaymentClaimable) {
+	let (_, bob_payment_preimage) = match get_event!(bob, Event::PaymentClaimable) {
 		Event::PaymentClaimable { purpose, .. } => {
 			let preimage = match purpose.preimage() {
 				Some(p) => p,
 				None => panic!("No preimage in PaymentClaimable"),
 			};
 			(purpose, preimage)
 		},
-		_ => panic!("No Event::PaymentClaimable for Alice"),
+		_ => panic!("No Event::PaymentClaimable for Bob"),
 	};
 
-	let (_, _) = claim_payment(bob, &[alice], alice_payment_preimage);
-	expect_recent_payment!(bob, RecentPaymentDetails::Fulfilled, payment_id);
+	let (_, _) = claim_payment(alice, &[bob], bob_payment_preimage);
+	expect_recent_payment!(alice, RecentPaymentDetails::Fulfilled, payment_id);
 }

lightning/src/offers/flow.rs

@@ -574,6 +574,33 @@ where
 		Ok((builder.into(), nonce))
 	}
 
+	/// Creates a minimal [`OfferBuilder`] with derived metadata but no blinded paths.
+	///
+	/// This is useful for scenarios where size constraints require the smallest possible offer,
+	/// such as including a payer offer in a BLIP-42 invoice request. The resulting offer uses
+	/// derived metadata (so invoice requests can be verified) but has no blinded paths, making
+	/// it very compact (~70 bytes).
+	///
+	/// # Privacy
+	///
+	/// This offer exposes the derived signing pubkey directly without any blinded path privacy.
+	/// This is acceptable for BLIP-42 use cases where the payer is intentionally sharing
+	/// their contact information with the recipient.
+	///
+	/// This is not exported to bindings users as builder patterns don't map outside of move semantics.
+	pub fn create_compact_offer_builder<ES: Deref>(
+		&self, entropy_source: ES,
+	) -> Result<OfferBuilder<'_, DerivedMetadata, secp256k1::All>, Bolt12SemanticError>
+	where
+		ES::Target: EntropySource,
+	{
+		// Use the internal builder but don't add any paths
+		self.create_offer_builder_intern(&*entropy_source, |_, _, _| {
+			Ok(core::iter::empty())
+		})
+		.map(|(builder, _)| builder)
+	}
+
 	/// Creates an [`OfferBuilder`] such that the [`Offer`] it builds is recognized by the
 	/// [`OffersMessageFlow`], and any corresponding [`InvoiceRequest`] can be verified using
 	/// [`Self::verify_invoice_request`]. The offer will expire at `absolute_expiry` if `Some`,