Merge pull request #4539 from TheBlueMatt/2026-04-drop-native-dns

Drop `ChannelManager`-built-in BIP 353 resolution logic

Author: tnull

lightning-dns-resolver/src/lib.rs

@@ -147,32 +147,21 @@ mod test {
 	use super::*;
 
 	use bitcoin::secp256k1::{self, PublicKey, Secp256k1};
-	use bitcoin::Block;
 
 	use lightning::blinded_path::message::{
 		BlindedMessagePath, MessageContext, MessageForwardNode,
 	};
 	use lightning::blinded_path::NodeIdLookUp;
-	use lightning::events::{Event, PaymentPurpose};
-	use lightning::ln::channelmanager::{OptionalOfferPaymentParams, PaymentId};
-	use lightning::ln::functional_test_utils::*;
-	use lightning::ln::msgs::{
-		BaseMessageHandler, ChannelMessageHandler, Init, OnionMessageHandler,
-	};
-	use lightning::offers::offer::Offer;
+	use lightning::ln::channelmanager::PaymentId;
+	use lightning::ln::msgs::{BaseMessageHandler, Init, OnionMessageHandler};
 	use lightning::onion_message::dns_resolution::{HumanReadableName, OMNameResolver};
 	use lightning::onion_message::messenger::{
 		AOnionMessenger, Destination, MessageRouter, OnionMessagePath, OnionMessenger,
 	};
-	use lightning::routing::router::DEFAULT_PAYMENT_DUMMY_HOPS;
 	use lightning::sign::{KeysManager, NodeSigner, ReceiveAuthKey, Recipient};
 	use lightning::types::features::InitFeatures;
-	use lightning::types::payment::PaymentHash;
 	use lightning::util::logger::Logger;
 
-	use lightning::expect_payment_claimed;
-	use lightning_types::string::UntrustedString;
-
 	use std::sync::Mutex;
 	use std::time::{Duration, Instant, SystemTime};
 
@@ -348,153 +337,4 @@ mod test {
 		assert_eq!(resolution.1, payment_id);
 		assert!(resolution.2[.."bitcoin:".len()].eq_ignore_ascii_case("bitcoin:"));
 	}
-
-	async fn pay_offer_flow<'a, 'b, 'c>(
-		nodes: &[Node<'a, 'b, 'c>], resolver_messenger: &impl AOnionMessenger,
-		resolver_id: PublicKey, payer_id: PublicKey, payee_id: PublicKey, offer: Offer,
-		name: HumanReadableName, payment_id: PaymentId, payer_note: Option<String>,
-		resolvers: Vec<Destination>,
-	) {
-		// Override contents to offer provided
-		let proof_override = &nodes[0].node.testing_dnssec_proof_offer_resolution_override;
-		proof_override.lock().unwrap().insert(name.clone(), offer);
-		let amt = 42_000;
-		let mut opts = OptionalOfferPaymentParams::default();
-		opts.payer_note = payer_note.clone();
-		#[allow(deprecated)]
-		nodes[0]
-			.node
-			.pay_for_offer_from_human_readable_name(name, amt, payment_id, opts, resolvers)
-			.unwrap();
-
-		let query = nodes[0].onion_messenger.next_onion_message_for_peer(resolver_id).unwrap();
-		resolver_messenger.get_om().handle_onion_message(payer_id, &query);
-
-		assert!(resolver_messenger.get_om().next_onion_message_for_peer(payer_id).is_none());
-		let start = Instant::now();
-		let response = loop {
-			tokio::time::sleep(Duration::from_millis(10)).await;
-			if let Some(msg) = resolver_messenger.get_om().next_onion_message_for_peer(payer_id) {
-				break msg;
-			}
-			assert!(start.elapsed() < Duration::from_secs(10), "Resolution took too long");
-		};
-
-		nodes[0].onion_messenger.handle_onion_message(resolver_id, &response);
-
-		let invreq = nodes[0].onion_messenger.next_onion_message_for_peer(payee_id).unwrap();
-		nodes[1].onion_messenger.handle_onion_message(payer_id, &invreq);
-
-		let inv = nodes[1].onion_messenger.next_onion_message_for_peer(payer_id).unwrap();
-		nodes[0].onion_messenger.handle_onion_message(payee_id, &inv);
-
-		check_added_monitors(&nodes[0], 1);
-		let updates = get_htlc_update_msgs(&nodes[0], &payee_id);
-		nodes[1].node.handle_update_add_htlc(payer_id, &updates.update_add_htlcs[0]);
-		do_commitment_signed_dance(&nodes[1], &nodes[0], &updates.commitment_signed, false, false);
-
-		for _ in 0..DEFAULT_PAYMENT_DUMMY_HOPS {
-			assert!(nodes[1].node.needs_pending_htlc_processing());
-			nodes[1].node.process_pending_htlc_forwards();
-		}
-
-		expect_and_process_pending_htlcs(&nodes[1], false);
-
-		let claimable_events = nodes[1].node.get_and_clear_pending_events();
-		assert_eq!(claimable_events.len(), 1);
-		let our_payment_preimage;
-		if let Event::PaymentClaimable { purpose, amount_msat, .. } = &claimable_events[0] {
-			assert_eq!(*amount_msat, amt);
-			if let PaymentPurpose::Bolt12OfferPayment {
-				payment_preimage, payment_context, ..
-			} = purpose
-			{
-				our_payment_preimage = payment_preimage.unwrap();
-				nodes[1].node.claim_funds(our_payment_preimage);
-				let payment_hash: PaymentHash = our_payment_preimage.into();
-				expect_payment_claimed!(nodes[1], payment_hash, amt);
-				if let Some(note) = payer_note {
-					assert_eq!(
-						payment_context.invoice_request.payer_note_truncated,
-						Some(UntrustedString(note.into()))
-					);
-				} else {
-					assert_eq!(payment_context.invoice_request.payer_note_truncated, None);
-				}
-			} else {
-				panic!();
-			}
-		} else {
-			panic!();
-		}
-
-		check_added_monitors(&nodes[1], 1);
-		let mut updates = get_htlc_update_msgs(&nodes[1], &payer_id);
-		nodes[0].node.handle_update_fulfill_htlc(payee_id, updates.update_fulfill_htlcs.remove(0));
-		do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
-
-		expect_payment_sent(&nodes[0], our_payment_preimage, None, true, true);
-	}
-
-	#[tokio::test]
-	async fn end_to_end_test() {
-		let chanmon_cfgs = create_chanmon_cfgs(2);
-		let node_cfgs = create_node_cfgs_with_node_id_message_router(2, &chanmon_cfgs);
-		let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
-		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
-
-		create_announced_chan_between_nodes(&nodes, 0, 1);
-
-		// The DNSSEC validation will only work with the current time, so set the time on the
-		// resolver.
-		let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
-		let block = Block {
-			header: create_dummy_header(nodes[0].best_block_hash(), now as u32),
-			txdata: Vec::new(),
-		};
-		connect_block(&nodes[0], &block);
-		connect_block(&nodes[1], &block);
-
-		let payer_id = nodes[0].node.get_our_node_id();
-		let payee_id = nodes[1].node.get_our_node_id();
-
-		let (resolver_messenger, resolver_id) = create_resolver();
-		let init_msg = get_om_init();
-		nodes[0].onion_messenger.peer_connected(resolver_id, &init_msg, true).unwrap();
-		resolver_messenger.get_om().peer_connected(payer_id, &init_msg, false).unwrap();
-
-		let name = HumanReadableName::from_encoded("matt@mattcorallo.com").unwrap();
-
-		let bs_offer = nodes[1].node.create_offer_builder().unwrap().build().unwrap();
-		let resolvers = vec![Destination::Node(resolver_id)];
-
-		pay_offer_flow(
-			&nodes,
-			&resolver_messenger,
-			resolver_id,
-			payer_id,
-			payee_id,
-			bs_offer.clone(),
-			name.clone(),
-			PaymentId([42; 32]),
-			None,
-			resolvers.clone(),
-		)
-		.await;
-
-		// Pay offer with payer_note
-		pay_offer_flow(
-			&nodes,
-			&resolver_messenger,
-			resolver_id,
-			payer_id,
-			payee_id,
-			bs_offer,
-			name,
-			PaymentId([21; 32]),
-			Some("foo".into()),
-			resolvers,
-		)
-		.await;
-	}
 }