diff --git a/lightning-dns-resolver/src/lib.rs b/lightning-dns-resolver/src/lib.rs index e9578844cf8..c6d583ab745 100644 --- a/lightning-dns-resolver/src/lib.rs +++ b/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, - resolvers: Vec, - ) { - // 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; - } } diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index 2e782701e47..660875400c7 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -142,15 +142,6 @@ use crate::util::wakers::{Future, Notifier}; #[cfg(test)] use crate::blinded_path::payment::BlindedPaymentPath; -#[cfg(feature = "dnssec")] -use { - crate::blinded_path::message::DNSResolverContext, - crate::onion_message::dns_resolution::{ - DNSResolverMessage, DNSResolverMessageHandler, DNSSECProof, DNSSECQuery, - }, - crate::onion_message::messenger::Destination, -}; - #[cfg(c_bindings)] use { crate::offers::offer::OfferWithDerivedMetadataBuilder, @@ -715,12 +706,7 @@ impl Default for OptionalBolt11PaymentParams { } } -/// Optional arguments to [`ChannelManager::pay_for_offer`] -#[cfg_attr( - feature = "dnssec", - doc = "and [`ChannelManager::pay_for_offer_from_human_readable_name`]" -)] -/// . +/// Optional arguments to [`ChannelManager::pay_for_offer`]. /// /// These fields will often not need to be set, and the provided [`Self::default`] can be used. pub struct OptionalOfferPaymentParams { @@ -2942,14 +2928,6 @@ pub struct ChannelManager< /// [`ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee`] estimate. last_days_feerates: Mutex>, - #[cfg(feature = "_test_utils")] - /// In testing, it is useful be able to forge a name -> offer mapping so that we can pay an - /// offer generated in the test. - /// - /// This allows for doing so, validating proofs as normal, but, if they pass, replacing the - /// offer they resolve to to the given one. - pub testing_dnssec_proof_offer_resolution_override: Mutex>, - #[cfg(test)] pub(super) entropy_source: ES, #[cfg(not(test))] @@ -3680,9 +3658,6 @@ impl< signer_provider, logger, - - #[cfg(feature = "_test_utils")] - testing_dnssec_proof_offer_resolution_override: Mutex::new(new_hash_map()), } } @@ -5704,6 +5679,12 @@ impl< /// # Custom Routing Parameters /// Users can customize routing parameters via [`RouteParametersConfig`]. /// To use default settings, call the function with [`RouteParametersConfig::default`]. + /// + /// In general, you should use the + /// [`bitcoin-payment-instructions` crate](https://docs.rs/bitcoin-payment-instructions/) to + /// resolve payment instructions strings (e.g. from QR codes, link opens, pasted instructions, + /// or typed instructions) into payment instructions and use this when the instructions resolve + /// to a BOLT 11 invoice. pub fn pay_for_bolt11_invoice( &self, invoice: &Bolt11Invoice, payment_id: PaymentId, amount_msats: Option, optional_params: OptionalBolt11PaymentParams, @@ -14588,6 +14569,12 @@ impl< /// - the parameterized [`Router`] is unable to create a blinded reply path for the invoice /// request. /// + /// In general, you should use the + /// [`bitcoin-payment-instructions` crate](https://docs.rs/bitcoin-payment-instructions/) to + /// resolve payment instructions strings (e.g. from QR codes, link opens, pasted instructions, + /// or typed instructions) into payment instructions and use this when the instructions resolve + /// to a BOLT 12 offer. + /// /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest /// [`InvoiceRequestBuilder`]: crate::offers::invoice_request::InvoiceRequestBuilder /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice @@ -14787,72 +14774,6 @@ impl< Ok(invoice) } - /// Pays for an [`Offer`] looked up using [BIP 353] Human Readable Names resolved by the DNS - /// resolver(s) at `dns_resolvers` which resolve names according to [bLIP 32]. - /// - /// Because most wallets support on-chain or other payment schemes beyond only offers, this is - /// deprecated in favor of the [`bitcoin-payment-instructions`] crate, which can be used to - /// build an [`OfferFromHrn`] and call [`Self::pay_for_offer_from_hrn`]. Thus, this method is - /// deprecated. - /// - /// # Payment - /// - /// The provided `payment_id` is used to ensure that only one invoice is paid for the request - /// when received. See [Avoiding Duplicate Payments] for other requirements once the payment has - /// been sent. - /// - /// To revoke the request, use [`ChannelManager::abandon_payment`] prior to receiving the - /// invoice. If abandoned, or an invoice isn't received in a reasonable amount of time, the - /// payment will fail with an [`PaymentFailureReason::UserAbandoned`] or - /// [`PaymentFailureReason::InvoiceRequestExpired`], respectively. - /// - /// # Privacy - /// - /// For payer privacy, uses a derived payer id and uses [`MessageRouter::create_blinded_paths`] - /// to construct a [`BlindedMessagePath`] for the reply path. - /// - /// # Errors - /// - /// Errors if a duplicate `payment_id` is provided given the caveats in the aforementioned link. - /// - /// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki - /// [bLIP 32]: https://github.com/lightning/blips/blob/master/blip-0032.md - /// [`OMNameResolver::resolve_name`]: crate::onion_message::dns_resolution::OMNameResolver::resolve_name - /// [`OMNameResolver::handle_dnssec_proof_for_uri`]: crate::onion_message::dns_resolution::OMNameResolver::handle_dnssec_proof_for_uri - /// [`bitcoin-payment-instructions`]: https://docs.rs/bitcoin-payment-instructions/ - /// [Avoiding Duplicate Payments]: #avoiding-duplicate-payments - /// [`BlindedMessagePath`]: crate::blinded_path::message::BlindedMessagePath - /// [`PaymentFailureReason::UserAbandoned`]: crate::events::PaymentFailureReason::UserAbandoned - /// [`PaymentFailureReason::InvoiceRequestRejected`]: crate::events::PaymentFailureReason::InvoiceRequestRejected - #[cfg(feature = "dnssec")] - #[deprecated(note = "Use bitcoin-payment-instructions and pay_for_offer_from_hrn instead")] - pub fn pay_for_offer_from_human_readable_name( - &self, name: HumanReadableName, amount_msats: u64, payment_id: PaymentId, - optional_params: OptionalOfferPaymentParams, dns_resolvers: Vec, - ) -> Result<(), ()> { - let (onion_message, context) = - self.flow.hrn_resolver.resolve_name(payment_id, name, &self.entropy_source)?; - - let expiration = StaleExpiration::TimerTicks(1); - self.pending_outbound_payments.add_new_awaiting_offer( - payment_id, - expiration, - optional_params.retry_strategy, - optional_params.route_params_config, - amount_msats, - optional_params.payer_note, - )?; - - self.flow - .enqueue_dns_onion_message( - onion_message, - context, - dns_resolvers, - self.get_peers_for_blinded_path(), - ) - .map_err(|_| ()) - } - /// Gets a payment secret and payment hash for use in an invoice given to a third party wishing /// to pay us. /// @@ -17398,65 +17319,6 @@ impl< } } -#[cfg(feature = "dnssec")] -impl< - M: chain::Watch, - T: BroadcasterInterface, - ES: EntropySource, - NS: NodeSigner, - SP: SignerProvider, - F: FeeEstimator, - R: Router, - MR: MessageRouter, - L: Logger, - > DNSResolverMessageHandler for ChannelManager -{ - fn handle_dnssec_query( - &self, _message: DNSSECQuery, _responder: Option, - ) -> Option<(DNSResolverMessage, ResponseInstruction)> { - None - } - - #[rustfmt::skip] - fn handle_dnssec_proof(&self, message: DNSSECProof, context: DNSResolverContext) { - let offer_opt = self.flow.hrn_resolver.handle_dnssec_proof_for_offer(message, context); - #[cfg_attr(not(feature = "_test_utils"), allow(unused_mut))] - if let Some((completed_requests, mut offer)) = offer_opt { - for (name, payment_id) in completed_requests { - #[cfg(feature = "_test_utils")] - if let Some(replacement_offer) = self.testing_dnssec_proof_offer_resolution_override.lock().unwrap().remove(&name) { - // If we have multiple pending requests we may end up over-using the override - // offer, but tests can deal with that. - offer = replacement_offer; - } - if let Ok((amt_msats, payer_note)) = self.pending_outbound_payments.params_for_payment_awaiting_offer(payment_id) { - let offer_pay_res = - self.pay_for_offer_intern(&offer, None, Some(amt_msats), payer_note, payment_id, Some(name), - |retryable_invoice_request| { - self.pending_outbound_payments - .received_offer(payment_id, Some(retryable_invoice_request)) - .map_err(|_| Bolt12SemanticError::DuplicatePaymentId) - }); - 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 - // payment. - // Note that the PaymentFailureReason should be ignored for an - // AwaitingInvoice payment. - self.pending_outbound_payments.abandon_payment( - payment_id, PaymentFailureReason::RouteNotFound, &self.pending_events, - ); - } - } - } - } - } - - fn release_pending_messages(&self) -> Vec<(DNSResolverMessage, MessageSendInstructions)> { - self.flow.release_pending_dns_messages() - } -} - impl< M: chain::Watch, T: BroadcasterInterface, @@ -20233,9 +20095,6 @@ impl< logger: args.logger, config: RwLock::new(args.config), - - #[cfg(feature = "_test_utils")] - testing_dnssec_proof_offer_resolution_override: Mutex::new(new_hash_map()), }; let mut processed_claims: HashSet> = new_hash_set(); diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index 84cdf785da5..d39cee78b0f 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -521,7 +521,6 @@ pub type TestChannelManager<'node_cfg, 'chan_mon_cfg> = ChannelManager< &'chan_mon_cfg test_utils::TestLogger, >; -#[cfg(not(feature = "dnssec"))] type TestOnionMessenger<'chan_man, 'node_cfg, 'chan_mon_cfg> = OnionMessenger< DedicatedEntropy, &'node_cfg test_utils::TestKeysInterface, @@ -534,19 +533,6 @@ type TestOnionMessenger<'chan_man, 'node_cfg, 'chan_mon_cfg> = OnionMessenger< IgnoringMessageHandler, >; -#[cfg(feature = "dnssec")] -type TestOnionMessenger<'chan_man, 'node_cfg, 'chan_mon_cfg> = OnionMessenger< - DedicatedEntropy, - &'node_cfg test_utils::TestKeysInterface, - &'chan_mon_cfg test_utils::TestLogger, - &'chan_man TestChannelManager<'node_cfg, 'chan_mon_cfg>, - &'node_cfg test_utils::TestMessageRouter<'chan_mon_cfg>, - &'chan_man TestChannelManager<'node_cfg, 'chan_mon_cfg>, - &'chan_man TestChannelManager<'node_cfg, 'chan_mon_cfg>, - &'chan_man TestChannelManager<'node_cfg, 'chan_mon_cfg>, - IgnoringMessageHandler, ->; - /// For use with [`OnionMessenger`] otherwise `test_restored_packages_retry` will fail. This is /// because that test uses older serialized data produced by calling [`EntropySource`] in a specific /// manner. Using the same [`EntropySource`] with [`OnionMessenger`] would introduce another call, @@ -4797,19 +4783,6 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>( for i in 0..node_count { let dedicated_entropy = DedicatedEntropy(RandomBytes::new([i as u8; 32])); - #[cfg(feature = "dnssec")] - let onion_messenger = OnionMessenger::new_with_offline_peer_interception( - dedicated_entropy, - cfgs[i].keys_manager, - cfgs[i].logger, - &chan_mgrs[i], - &cfgs[i].message_router, - &chan_mgrs[i], - &chan_mgrs[i], - &chan_mgrs[i], - IgnoringMessageHandler {}, - ); - #[cfg(not(feature = "dnssec"))] let onion_messenger = OnionMessenger::new_with_offline_peer_interception( dedicated_entropy, cfgs[i].keys_manager, diff --git a/lightning/src/ln/outbound_payment.rs b/lightning/src/ln/outbound_payment.rs index 9241e6ccf7c..7259f60796f 100644 --- a/lightning/src/ln/outbound_payment.rs +++ b/lightning/src/ln/outbound_payment.rs @@ -2033,65 +2033,6 @@ impl OutboundPayments { (payment, onion_session_privs) } - #[cfg(feature = "dnssec")] - pub(super) fn add_new_awaiting_offer( - &self, payment_id: PaymentId, expiration: StaleExpiration, retry_strategy: Retry, - route_params_config: RouteParametersConfig, amount_msats: u64, payer_note: Option, - ) -> Result<(), ()> { - let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap(); - match pending_outbounds.entry(payment_id) { - hash_map::Entry::Occupied(_) => Err(()), - hash_map::Entry::Vacant(entry) => { - entry.insert(PendingOutboundPayment::AwaitingOffer { - expiration, - retry_strategy, - route_params_config, - amount_msats, - payer_note, - }); - - Ok(()) - }, - } - } - - #[cfg(feature = "dnssec")] - #[rustfmt::skip] - pub(super) fn params_for_payment_awaiting_offer(&self, payment_id: PaymentId) -> Result<(u64, Option), ()> { - match self.pending_outbound_payments.lock().unwrap().entry(payment_id) { - hash_map::Entry::Occupied(entry) => match entry.get() { - PendingOutboundPayment::AwaitingOffer { amount_msats, payer_note, .. } => Ok((*amount_msats, payer_note.clone())), - _ => Err(()), - }, - _ => Err(()), - } - } - - #[cfg(feature = "dnssec")] - #[rustfmt::skip] - pub(super) fn received_offer( - &self, payment_id: PaymentId, retryable_invoice_request: Option, - ) -> Result<(), ()> { - match self.pending_outbound_payments.lock().unwrap().entry(payment_id) { - hash_map::Entry::Occupied(entry) => match entry.get() { - PendingOutboundPayment::AwaitingOffer { - expiration, retry_strategy, route_params_config, .. - } => { - let mut new_val = PendingOutboundPayment::AwaitingInvoice { - expiration: *expiration, - retry_strategy: *retry_strategy, - route_params_config: *route_params_config, - retryable_invoice_request, - }; - core::mem::swap(&mut new_val, entry.into_mut()); - Ok(()) - }, - _ => Err(()), - }, - hash_map::Entry::Vacant(_) => Err(()), - } - } - pub(super) fn add_new_awaiting_invoice( &self, payment_id: PaymentId, expiration: StaleExpiration, retry_strategy: Retry, route_params_config: RouteParametersConfig, @@ -2886,6 +2827,8 @@ impl_writeable_tlv_based_enum_upgradable!(PendingOutboundPayment, }, // Added in 0.1. Prior versions will drop these outbounds on downgrade, which is safe because // no HTLCs are in-flight. + // No longer created in 0.3 as we now expect BIP 353 to happen before a payment makes it into + // the `lightning` crate. (11, AwaitingOffer) => { (0, expiration, required), (2, retry_strategy, required), diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs index f94eb7877f5..7ef4e4a66a8 100644 --- a/lightning/src/onion_message/messenger.rs +++ b/lightning/src/onion_message/messenger.rs @@ -2340,28 +2340,6 @@ impl< /// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager /// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager #[cfg(not(c_bindings))] -#[cfg(feature = "dnssec")] -pub type SimpleArcOnionMessenger = OnionMessenger< - Arc, - Arc, - Arc, - Arc>, - Arc>>, Arc, Arc>>, - Arc>, - Arc>, - Arc>, - IgnoringMessageHandler, ->; - -/// Useful for simplifying the parameters of [`SimpleArcChannelManager`] and -/// [`SimpleArcPeerManager`]. See their docs for more details. -/// -/// This is not exported to bindings users as type aliases aren't supported in most languages. -/// -/// [`SimpleArcChannelManager`]: crate::ln::channelmanager::SimpleArcChannelManager -/// [`SimpleArcPeerManager`]: crate::ln::peer_handler::SimpleArcPeerManager -#[cfg(not(c_bindings))] -#[cfg(not(feature = "dnssec"))] pub type SimpleArcOnionMessenger = OnionMessenger< Arc, Arc, @@ -2382,29 +2360,6 @@ pub type SimpleArcOnionMessenger = OnionMessenger< /// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager /// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager #[cfg(not(c_bindings))] -#[cfg(feature = "dnssec")] -pub type SimpleRefOnionMessenger<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, M, T, F, L> = - OnionMessenger< - &'a KeysManager, - &'a KeysManager, - &'b L, - &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, M, T, F, L>, - &'i DefaultMessageRouter<&'g NetworkGraph<&'b L>, &'b L, &'a KeysManager>, - &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, M, T, F, L>, - &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, M, T, F, L>, - &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, M, T, F, L>, - IgnoringMessageHandler, - >; - -/// Useful for simplifying the parameters of [`SimpleRefChannelManager`] and -/// [`SimpleRefPeerManager`]. See their docs for more details. -/// -/// This is not exported to bindings users as type aliases aren't supported in most languages. -/// -/// [`SimpleRefChannelManager`]: crate::ln::channelmanager::SimpleRefChannelManager -/// [`SimpleRefPeerManager`]: crate::ln::peer_handler::SimpleRefPeerManager -#[cfg(not(c_bindings))] -#[cfg(not(feature = "dnssec"))] pub type SimpleRefOnionMessenger<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, M, T, F, L> = OnionMessenger< &'a KeysManager,