f use a smaller offer

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

Author: vincenzopalazzo

lightning/src/ln/channelmanager.rs

@@ -732,6 +732,31 @@ pub struct OptionalOfferPaymentParams {
 	/// Contact secrets to include in the invoice request for BLIP-42 contact management.
 	/// If provided, these secrets will be used to establish a contact relationship with the recipient.
 	pub contact_secrects: Option<ContactSecrets>,
+	/// A custom payer offer to include in the invoice request for BLIP-42 contact management.
+	///
+	/// If provided, this offer will be included in the invoice request, allowing the recipient to
+	/// contact you back. If `None`, **no payer offer will be included** in the invoice request.
+	///
+	/// You can create custom offers using [`OffersMessageFlow::create_compact_offer_builder`]:
+	/// - Pass `None` for no blinded path (smallest size, ~70 bytes)
+	/// - Pass `Some(intro_node_id)` for a single blinded path (~200 bytes)
+	///
+	/// # Example
+	/// ```rust,ignore
+	/// // Include a compact offer with a single blinded path
+	/// let payer_offer = flow.create_compact_offer_builder(
+	///     &entropy_source,
+	///     Some(trusted_peer_pubkey)
+	/// )?.build()?;
+	///
+	/// let params = OptionalOfferPaymentParams {
+	///     payer_offer: Some(payer_offer),
+	///     ..Default::default()
+	/// };
+	/// ```
+	///
+	/// [`OffersMessageFlow::create_compact_offer_builder`]: crate::offers::flow::OffersMessageFlow::create_compact_offer_builder
+	pub payer_offer: Option<Offer>,
 }
 
 impl Default for OptionalOfferPaymentParams {
@@ -744,6 +769,7 @@ impl Default for OptionalOfferPaymentParams {
 			#[cfg(not(feature = "std"))]
 			retry_strategy: Retry::Attempts(3),
 			contact_secrects: None,
+			payer_offer: None,
 		}
 	}
 }
@@ -12950,6 +12976,7 @@ where
 			None,
 			create_pending_payment_fn,
 			optional_params.contact_secrects,
+			optional_params.payer_offer,
 		)
 	}
 
@@ -12980,6 +13007,7 @@ where
 			Some(offer.hrn),
 			create_pending_payment_fn,
 			optional_params.contact_secrects,
+			optional_params.payer_offer,
 		)
 	}
 
@@ -13023,6 +13051,7 @@ where
 			None,
 			create_pending_payment_fn,
 			optional_params.contact_secrects,
+			optional_params.payer_offer,
 		)
 	}
 
@@ -13031,7 +13060,7 @@ where
 		&self, offer: &Offer, quantity: Option<u64>, amount_msats: Option<u64>,
 		payer_note: Option<String>, payment_id: PaymentId,
 		human_readable_name: Option<HumanReadableName>, create_pending_payment: CPP,
-		contacts: Option<ContactSecrets>,
+		contacts: Option<ContactSecrets>, payer_offer: Option<Offer>,
 	) -> Result<(), Bolt12SemanticError> {
 		let entropy = &*self.entropy_source;
 		let nonce = Nonce::from_entropy_source(entropy);
@@ -13062,11 +13091,14 @@ 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()?;
-		let builder = builder.payer_offer(&payer_offer);
+
+		// Add payer offer only if provided by the user.
+		// If the user explicitly wants to include an offer, they should provide it via payer_offer parameter.
+		let builder = if let Some(offer) = payer_offer {
+			builder.payer_offer(&offer)
+		} else {
+			builder
+		};
 
 		let invoice_request = builder.build_and_sign()?;
 		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
@@ -15669,7 +15701,7 @@ where
 								self.pending_outbound_payments
 									.received_offer(payment_id, Some(retryable_invoice_request))
 									.map_err(|_| Bolt12SemanticError::DuplicatePaymentId)
-						}, None);
+						}, None, None);
 					if offer_pay_res.is_err() {
 						// The offer we tried to pay is the canonical current offer for the name we
 						// wanted to pay. If we can't pay it, there's no way to recover so fail the

lightning/src/ln/offers_tests.rs

@@ -2575,9 +2575,13 @@ fn pay_offer_and_add_contacts_info_blip42() {
 		.private_key;
 	let bob_contact_secrets = compute_contact_secret(&bob_private_key, &offer);
 
+	// Create a compact payer offer for Bob to include in the invoice request
+	let bob_payer_offer = bob.node.flow.create_compact_offer_builder(&*bob.node.entropy_source, None).unwrap().build().unwrap();
+
 	let payment_id = PaymentId([1; 32]);
 	bob.node.pay_for_offer(&offer, None, payment_id, OptionalOfferPaymentParams {
 		contact_secrects: Some(bob_contact_secrets),
+		payer_offer: Some(bob_payer_offer),
 		..Default::default()
 	}).unwrap();
 
@@ -2640,9 +2644,13 @@ fn pay_offer_and_add_contacts_info_blip42() {
 	let alice_contact_secret = alice_invoice_request_fields.contact_secret.unwrap();
 	let alice_payer_offer = alice_invoice_request_fields.payer_offer.unwrap();
 
+	// Create a compact payer offer for Alice to include in the invoice request
+	let alice_payer_offer_for_bob = alice.node.flow.create_compact_offer_builder(&*alice.node.entropy_source, None).unwrap().build().unwrap();
+
 	let payment_id = PaymentId([1; 32]);
 	alice.node.pay_for_offer(&alice_payer_offer, Some(5_000_000), payment_id, OptionalOfferPaymentParams{
 		contact_secrects: Some(ContactSecrets::new(alice_contact_secret)),
+		payer_offer: Some(alice_payer_offer_for_bob),
 		..Default::default()
 	}).unwrap();
 
@@ -2659,27 +2667,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,45 @@ where
 		Ok((builder.into(), nonce))
 	}
 
+	/// Creates a minimal [`OfferBuilder`] with derived metadata and an optional blinded path.
+	///
+	/// If `intro_node_id` is `None`, creates an offer with no blinded paths (~70 bytes) suitable
+	/// for scenarios like BLIP-42 where the payer intentionally shares their contact info.
+	///
+	/// If `intro_node_id` is `Some`, creates an offer with a single blinded path (~200 bytes)
+	/// providing privacy/routability for unannounced nodes. The intro node must be a public
+	/// peer (routable via gossip) with an outbound channel.
+	///
+	/// # Privacy
+	///
+	/// - `None`: Exposes the derived signing pubkey directly without blinded path privacy
+	/// - `Some`: Intro node learns payer identity (choose trusted/routable peer)
+	///
+	/// 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, intro_node_id: Option<PublicKey>,
+	) -> Result<OfferBuilder<'_, DerivedMetadata, secp256k1::All>, Bolt12SemanticError>
+	where
+		ES::Target: EntropySource,
+	{
+		match intro_node_id {
+			None => {
+				// Use the internal builder but don't add any paths
+				self.create_offer_builder_intern(&*entropy_source, |_, _, _| {
+					Ok(core::iter::empty())
+				})
+				.map(|(builder, _)| builder)
+			},
+			Some(node_id) => {
+				// Delegate to create_offer_builder with a single-peer list to reuse the router logic
+				self.create_offer_builder(
+					entropy_source,
+					vec![MessageForwardNode { node_id, short_channel_id: None }],
+				)
+			},
+		}
+	}
+
 	/// 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`,