Add create_contact_offer for compact BLIP-42 offers

Adds `create_contact_offer` method to `Bolt12Payment` that creates
compact offers suitable for BLIP-42's `payer_offer` field. These
offers have either no blinded paths or single-hop paths, making them
small enough to embed in invoice requests.

Also adds integration test for the complete BLIP-42 flow:
- Creating compact contact offers
- Sending payments with contact info
- Receiving payments with BLIP-42 fields

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

Author: vincenzopalazzo

Cargo.toml

@@ -129,6 +129,18 @@ name = "payments"
 harness = false
 
 #[patch.crates-io]
+#lightning = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-types = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-invoice = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-net-tokio = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-persister = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-background-processor = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-rapid-gossip-sync = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-block-sync = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-transaction-sync = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-liquidity = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+#lightning-macros = { git = "https://github.com/vincenzopalazzo/rust-lightning", branch = "macros/blip02-prep-v2" }
+
 #lightning = { path = "../rust-lightning/lightning" }
 #lightning-types = { path = "../rust-lightning/lightning-types" }
 #lightning-invoice = { path = "../rust-lightning/lightning-invoice" }

bindings/ldk_node.udl

@@ -237,6 +237,9 @@ interface Bolt12Payment {
 	Offer receive(u64 amount_msat, [ByRef]string description, u32? expiry_secs, u64? quantity);
 	[Throws=NodeError]
 	Offer receive_variable_amount([ByRef]string description, u32? expiry_secs);
+	/// Creates a compact contact offer for BLIP-42's payer_offer field.
+	[Throws=NodeError]
+	Offer create_contact_offer(PublicKey? intro_node);
 	[Throws=NodeError]
 	Bolt12Invoice request_refund_payment([ByRef]Refund refund);
 	[Throws=NodeError]

src/io/test_utils.rs

@@ -13,15 +13,15 @@ use std::sync::Mutex;
 
 use lightning::events::ClosureReason;
 use lightning::ln::functional_test_utils::{
-	check_closed_event, connect_block, create_announced_chan_between_nodes, create_chanmon_cfgs,
-	create_dummy_block, create_network, create_node_cfgs, create_node_chanmgrs, send_payment,
-	TestChanMonCfg,
+	check_added_monitors, check_closed_broadcast, check_closed_event, connect_block,
+	create_announced_chan_between_nodes, create_chanmon_cfgs, create_dummy_block, create_network,
+	create_node_cfgs, create_node_chanmgrs, send_payment, TestChanMonCfg,
 };
 use lightning::util::persist::{
 	KVStore, KVStoreSync, MonitorUpdatingPersister, KVSTORE_NAMESPACE_KEY_MAX_LEN,
 };
 use lightning::util::test_utils;
-use lightning::{check_added_monitors, check_closed_broadcast, io};
+use lightning::io;
 use rand::distr::Alphanumeric;
 use rand::{rng, Rng};
 
@@ -332,20 +332,20 @@ pub(crate) fn do_test_store<K: KVStoreSync + Sync>(store_0: &K, store_1: &K) {
 		&[nodes[1].node.get_our_node_id()],
 		100000,
 	);
-	check_closed_broadcast!(nodes[0], true);
-	check_added_monitors!(nodes[0], 1);
+	check_closed_broadcast(&nodes[0], 1, true);
+	check_added_monitors(&nodes[0], 1);
 
 	let node_txn = nodes[0].tx_broadcaster.txn_broadcast();
 	assert_eq!(node_txn.len(), 1);
 	let txn = vec![node_txn[0].clone(), node_txn[0].clone()];
 	let dummy_block = create_dummy_block(nodes[0].best_block_hash(), 42, txn);
 	connect_block(&nodes[1], &dummy_block);
 
-	check_closed_broadcast!(nodes[1], true);
+	check_closed_broadcast(&nodes[1], 1, true);
 	let reason = ClosureReason::CommitmentTxConfirmed;
 	let node_id_0 = nodes[0].node.get_our_node_id();
 	check_closed_event(&nodes[1], 1, reason, &[node_id_0], 100000);
-	check_added_monitors!(nodes[1], 1);
+	check_added_monitors(&nodes[1], 1);
 
 	// Make sure everything is persisted as expected after close.
 	check_persisted_data!(persister_0_max_pending_updates * 2 * EXPECTED_UPDATES_PER_PAYMENT + 1);

src/payment/bolt12.rs

@@ -13,6 +13,7 @@ use std::num::NonZeroU64;
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
+use bitcoin::secp256k1::PublicKey;
 use lightning::blinded_path::message::BlindedMessagePath;
 use lightning::ln::channelmanager::{OptionalOfferPaymentParams, PaymentId, Retry};
 use lightning::offers::contacts::ContactSecrets as LdkContactSecrets;
@@ -658,6 +659,74 @@ impl Bolt12Payment {
 		Ok(maybe_wrap(offer))
 	}
 
+	/// Creates a compact contact offer suitable for BLIP-42's `payer_offer` field.
+	///
+	/// Contact offers are designed to be embedded in invoice requests and should be
+	/// as compact as possible while still being payable. Unlike regular offers created
+	/// by [`receive`] or [`receive_variable_amount`], contact offers have minimal or
+	/// no blinded paths.
+	///
+	/// # Privacy Modes
+	///
+	/// - `intro_node: None` - Creates an offer with no blinded paths. The offer exposes
+	///   the node's derived signing pubkey directly. This is the most compact form but
+	///   provides no path privacy. Suitable when privacy is not a concern or when the
+	///   offer will only be shared with trusted contacts.
+	///
+	/// - `intro_node: Some(node_id)` - Creates an offer with a single blinded path through
+	///   the specified introduction node. The intro node should be a well-connected,
+	///   trusted peer that can route onion messages to this node.
+	///
+	/// # Example
+	///
+	/// ```ignore
+	/// // Create a compact contact offer (no privacy)
+	/// let contact_offer = node.bolt12_payment()
+	///     .create_contact_offer(None)
+	///     .unwrap();
+	///
+	/// // Create a contact offer with privacy through a trusted peer
+	/// let contact_offer = node.bolt12_payment()
+	///     .create_contact_offer(Some(trusted_peer_id))
+	///     .unwrap();
+	///
+	/// // Use it when paying someone with BLIP-42 contact info
+	/// let payment_id = node.bolt12_payment()
+	///     .send_with_contact(
+	///         &their_offer, None, None, None,
+	///         Some(contact_secrets),
+	///         Some(contact_offer),
+	///     )
+	///     .unwrap();
+	/// ```
+	///
+	/// See [BLIP-42](https://github.com/lightning/blips/blob/master/blip-0042.md) for more details.
+	///
+	/// [`receive`]: Self::receive
+	/// [`receive_variable_amount`]: Self::receive_variable_amount
+	pub fn create_contact_offer(&self, intro_node: Option<PublicKey>) -> Result<Offer, Error> {
+		let offer = self
+			.channel_manager
+			.create_compact_offer_builder(intro_node)
+			.map_err(|e| {
+				log_error!(self.logger, "Failed to create compact offer builder: {:?}", e);
+				Error::OfferCreationFailed
+			})?
+			.build()
+			.map_err(|e| {
+				log_error!(self.logger, "Failed to build contact offer: {:?}", e);
+				Error::OfferCreationFailed
+			})?;
+
+		log_info!(
+			self.logger,
+			"Created contact offer with intro_node: {:?}",
+			intro_node.map(|n| n.to_string())
+		);
+
+		Ok(maybe_wrap(offer))
+	}
+
 	/// Requests a refund payment for the given [`Refund`].
 	///
 	/// The returned [`Bolt12Invoice`] is for informational purposes only (i.e., isn't needed to

tests/integration_tests_rust.rs

@@ -1303,6 +1303,136 @@ async fn simple_bolt12_send_receive() {
 	assert_eq!(node_a_payments.first().unwrap().amount_msat, Some(overpaid_amount));
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn bolt12_with_blip42_contact() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = TestChainSource::Esplora(&electrsd);
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+
+	let address_a = node_a.onchain_payment().new_address().unwrap();
+	let premine_amount_sat = 5_000_000;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![address_a],
+		Amount::from_sat(premine_amount_sat),
+	)
+	.await;
+
+	node_a.sync_wallets().unwrap();
+	open_channel(&node_a, &node_b, 4_000_000, true, &electrsd).await;
+
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	expect_channel_ready_event!(node_a, node_b.node_id());
+	expect_channel_ready_event!(node_b, node_a.node_id());
+
+	// Sleep until we broadcasted a node announcement.
+	while node_b.status().latest_node_announcement_broadcast_timestamp.is_none() {
+		tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+	}
+	while node_a.status().latest_node_announcement_broadcast_timestamp.is_none() {
+		tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+	}
+
+	// Sleep one more sec to make sure the node announcements propagate.
+	tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+	// Node B creates an offer to receive payment
+	let expected_amount_msat = 100_000_000;
+	let node_b_offer =
+		node_b.bolt12_payment().receive(expected_amount_msat, "test payment", None, Some(1)).unwrap();
+
+	// Node A creates a COMPACT contact offer for BLIP-42's payer_offer field.
+	// Using None for intro_node creates an offer with no blinded paths (maximum compactness).
+	// This is suitable for embedding in invoice requests per BLIP-42 specification.
+	let node_a_offer = node_a.bolt12_payment().create_contact_offer(None).unwrap();
+
+	// Verify the contact offer is compact (either no paths or single-hop paths)
+	assert!(
+		node_a_offer.paths().is_empty()
+			|| node_a_offer.paths().iter().all(|p| p.blinded_hops().len() <= 1),
+		"Contact offer should be compact with no paths or single-hop paths"
+	);
+
+	// Create a contact secret (32 random bytes)
+	use ldk_node::payment::{ContactSecret, ContactSecrets};
+	let contact_secret_bytes: [u8; 32] = std::array::from_fn(|i| i as u8);
+	let contact_secret = ContactSecret::new(contact_secret_bytes);
+	let contact_secrets = ContactSecrets::new(contact_secret);
+
+	// Node A sends payment to Node B with BLIP-42 contact info
+	let payment_id = node_a
+		.bolt12_payment()
+		.send_with_contact(
+			&node_b_offer,
+			Some(1),
+			Some("BLIP-42 test".to_string()),
+			None,
+			Some(contact_secrets),
+			Some(node_a_offer.clone()),
+		)
+		.unwrap();
+
+	expect_payment_successful_event!(node_a, Some(payment_id), None);
+
+	// Node B should receive the payment with BLIP-42 contact information
+	let event = node_b.next_event_async().await;
+	match event {
+		Event::PaymentReceived {
+			amount_msat,
+			contact_secret: received_contact_secret,
+			payer_offer: received_payer_offer,
+			..
+		} => {
+			println!("Node B received payment with BLIP-42 contact info");
+			assert_eq!(amount_msat, expected_amount_msat);
+
+			// Verify contact_secret is present and matches
+			assert!(received_contact_secret.is_some(), "Expected contact_secret to be Some");
+			assert_eq!(
+				received_contact_secret.unwrap(),
+				contact_secret_bytes.to_vec(),
+				"Contact secret mismatch"
+			);
+
+			// Verify payer_offer is present
+			assert!(received_payer_offer.is_some(), "Expected payer_offer to be Some");
+			let payer_offer_str = received_payer_offer.unwrap();
+
+			// Parse the payer_offer and verify it matches node_a's offer
+			let parsed_offer: lightning::offers::offer::Offer =
+				payer_offer_str.parse().expect("Failed to parse payer_offer");
+			assert_eq!(
+				parsed_offer.id(),
+				node_a_offer.id(),
+				"Parsed offer ID should match node A's offer"
+			);
+
+			node_b.event_handled().unwrap();
+		},
+		ref e => {
+			panic!("Expected PaymentReceived event, got: {:?}", e);
+		},
+	}
+
+	// Verify payment records
+	let node_a_payments =
+		node_a.list_payments_with_filter(|p| matches!(p.kind, PaymentKind::Bolt12Offer { .. }));
+	assert_eq!(node_a_payments.len(), 1);
+	assert_eq!(node_a_payments.first().unwrap().amount_msat, Some(expected_amount_msat));
+	assert_eq!(node_a_payments.first().unwrap().status, PaymentStatus::Succeeded);
+
+	let node_b_payments =
+		node_b.list_payments_with_filter(|p| matches!(p.kind, PaymentKind::Bolt12Offer { .. }));
+	assert_eq!(node_b_payments.len(), 1);
+	assert_eq!(node_b_payments.first().unwrap().amount_msat, Some(expected_amount_msat));
+	assert_eq!(node_b_payments.first().unwrap().status, PaymentStatus::Succeeded);
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn async_payment() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();