1 // This file is Copyright its original authors, visible in version control
2 // history and in the source files from which this was generated.
4 // This file is licensed under the license available in the LICENSE or LICENSE.md
5 // file in the root of this repository or, if no such file exists, the same
6 // license as that which applies to the original source files from which this
7 // source was automatically generated.
9 //! Utilities to send payments and manage outbound payment information.
11 use alloc::str::FromStr;
12 use alloc::string::String;
13 use core::ffi::c_void;
14 use core::convert::Infallible;
15 use bitcoin::hashes::Hash;
16 use crate::c_types::*;
17 #[cfg(feature="no-std")]
18 use alloc::{vec::Vec, boxed::Box};
20 /// Strategies available to retry payment path failures.
25 /// Max number of attempts to retry payment.
27 /// Each attempt may be multiple HTLCs along multiple paths if the router decides to split up a
28 /// retry, and may retry multiple failed HTLCs at once if they failed around the same time and
29 /// were retried along a route from a single call to [`Router::find_route_with_id`].
32 /// Time elapsed before abandoning retries for a payment. At least one attempt at payment is made;
33 /// see [`PaymentParameters::expiry_time`] to avoid any attempt at payment after a specific time.
35 /// [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
39 use lightning::ln::outbound_payment::Retry as RetryImport;
40 pub(crate) type nativeRetry = RetryImport;
44 pub(crate) fn to_native(&self) -> nativeRetry {
46 Retry::Attempts (ref a, ) => {
47 let mut a_nonref = Clone::clone(a);
48 nativeRetry::Attempts (
52 Retry::Timeout (ref a, ) => {
53 let mut a_nonref = Clone::clone(a);
54 nativeRetry::Timeout (
55 core::time::Duration::from_secs(a_nonref),
61 pub(crate) fn into_native(self) -> nativeRetry {
63 Retry::Attempts (mut a, ) => {
64 nativeRetry::Attempts (
68 Retry::Timeout (mut a, ) => {
69 nativeRetry::Timeout (
70 core::time::Duration::from_secs(a),
76 pub(crate) fn from_native(native: &nativeRetry) -> Self {
78 nativeRetry::Attempts (ref a, ) => {
79 let mut a_nonref = Clone::clone(a);
84 nativeRetry::Timeout (ref a, ) => {
85 let mut a_nonref = Clone::clone(a);
93 pub(crate) fn native_into(native: nativeRetry) -> Self {
95 nativeRetry::Attempts (mut a, ) => {
100 nativeRetry::Timeout (mut a, ) => {
108 /// Frees any resources used by the Retry
110 pub extern "C" fn Retry_free(this_ptr: Retry) { }
111 /// Creates a copy of the Retry
113 pub extern "C" fn Retry_clone(orig: &Retry) -> Retry {
117 /// Utility method to constructs a new Attempts-variant Retry
118 pub extern "C" fn Retry_attempts(a: u32) -> Retry {
122 /// Utility method to constructs a new Timeout-variant Retry
123 pub extern "C" fn Retry_timeout(a: u64) -> Retry {
126 /// Checks if two Retrys contain equal inner contents.
127 /// This ignores pointers and is_owned flags and looks at the values in fields.
129 pub extern "C" fn Retry_eq(a: &Retry, b: &Retry) -> bool {
130 if &a.to_native() == &b.to_native() { true } else { false }
132 /// Generates a non-cryptographic 64-bit hash of the Retry.
134 pub extern "C" fn Retry_hash(o: &Retry) -> u64 {
135 // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
137 let mut hasher = core::hash::SipHasher::new();
138 core::hash::Hash::hash(&o.to_native(), &mut hasher);
139 core::hash::Hasher::finish(&hasher)
142 /// Serialize the Retry object into a byte array which can be read by Retry_read
143 pub extern "C" fn Retry_write(obj: &crate::lightning::ln::outbound_payment::Retry) -> crate::c_types::derived::CVec_u8Z {
144 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
147 /// Read a Retry from a byte array, created by Retry_write
148 pub extern "C" fn Retry_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RetryDecodeErrorZ {
149 let res: Result<lightning::ln::outbound_payment::Retry, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
150 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::outbound_payment::Retry::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
153 /// Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
154 /// surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
156 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
157 /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
158 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
162 pub enum RetryableSendFailure {
163 /// The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
164 /// that this error is *not* caused by [`Retry::Timeout`].
166 /// [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
168 /// We were unable to find a route to the destination.
170 /// Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
171 /// yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
173 /// [`PaymentId`]: crate::ln::channelmanager::PaymentId
174 /// [`Event::PaymentSent`]: crate::events::Event::PaymentSent
175 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
178 use lightning::ln::outbound_payment::RetryableSendFailure as RetryableSendFailureImport;
179 pub(crate) type nativeRetryableSendFailure = RetryableSendFailureImport;
181 impl RetryableSendFailure {
183 pub(crate) fn to_native(&self) -> nativeRetryableSendFailure {
185 RetryableSendFailure::PaymentExpired => nativeRetryableSendFailure::PaymentExpired,
186 RetryableSendFailure::RouteNotFound => nativeRetryableSendFailure::RouteNotFound,
187 RetryableSendFailure::DuplicatePayment => nativeRetryableSendFailure::DuplicatePayment,
191 pub(crate) fn into_native(self) -> nativeRetryableSendFailure {
193 RetryableSendFailure::PaymentExpired => nativeRetryableSendFailure::PaymentExpired,
194 RetryableSendFailure::RouteNotFound => nativeRetryableSendFailure::RouteNotFound,
195 RetryableSendFailure::DuplicatePayment => nativeRetryableSendFailure::DuplicatePayment,
199 pub(crate) fn from_native(native: &nativeRetryableSendFailure) -> Self {
201 nativeRetryableSendFailure::PaymentExpired => RetryableSendFailure::PaymentExpired,
202 nativeRetryableSendFailure::RouteNotFound => RetryableSendFailure::RouteNotFound,
203 nativeRetryableSendFailure::DuplicatePayment => RetryableSendFailure::DuplicatePayment,
207 pub(crate) fn native_into(native: nativeRetryableSendFailure) -> Self {
209 nativeRetryableSendFailure::PaymentExpired => RetryableSendFailure::PaymentExpired,
210 nativeRetryableSendFailure::RouteNotFound => RetryableSendFailure::RouteNotFound,
211 nativeRetryableSendFailure::DuplicatePayment => RetryableSendFailure::DuplicatePayment,
215 /// Creates a copy of the RetryableSendFailure
217 pub extern "C" fn RetryableSendFailure_clone(orig: &RetryableSendFailure) -> RetryableSendFailure {
221 /// Utility method to constructs a new PaymentExpired-variant RetryableSendFailure
222 pub extern "C" fn RetryableSendFailure_payment_expired() -> RetryableSendFailure {
223 RetryableSendFailure::PaymentExpired}
225 /// Utility method to constructs a new RouteNotFound-variant RetryableSendFailure
226 pub extern "C" fn RetryableSendFailure_route_not_found() -> RetryableSendFailure {
227 RetryableSendFailure::RouteNotFound}
229 /// Utility method to constructs a new DuplicatePayment-variant RetryableSendFailure
230 pub extern "C" fn RetryableSendFailure_duplicate_payment() -> RetryableSendFailure {
231 RetryableSendFailure::DuplicatePayment}
232 /// Checks if two RetryableSendFailures contain equal inner contents.
233 /// This ignores pointers and is_owned flags and looks at the values in fields.
235 pub extern "C" fn RetryableSendFailure_eq(a: &RetryableSendFailure, b: &RetryableSendFailure) -> bool {
236 if &a.to_native() == &b.to_native() { true } else { false }
238 /// If a payment fails to send with [`ChannelManager::send_payment_with_route`], it can be in one
239 /// of several states. This enum is returned as the Err() type describing which state the payment
240 /// is in, see the description of individual enum states for more.
242 /// [`ChannelManager::send_payment_with_route`]: crate::ln::channelmanager::ChannelManager::send_payment_with_route
246 pub enum PaymentSendFailure {
247 /// A parameter which was passed to send_payment was invalid, preventing us from attempting to
248 /// send the payment at all.
250 /// You can freely resend the payment in full (with the parameter error fixed).
252 /// Because the payment failed outright, no payment tracking is done and no
253 /// [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated.
255 /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
256 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
258 crate::lightning::util::errors::APIError),
259 /// A parameter in a single path which was passed to send_payment was invalid, preventing us
260 /// from attempting to send the payment at all.
262 /// You can freely resend the payment in full (with the parameter error fixed).
264 /// Because the payment failed outright, no payment tracking is done and no
265 /// [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated.
267 /// The results here are ordered the same as the paths in the route object which was passed to
270 /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
271 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
273 crate::c_types::derived::CVec_CResult_NoneAPIErrorZZ),
274 /// All paths which were attempted failed to send, with no channel state change taking place.
275 /// You can freely resend the payment in full (though you probably want to do so over different
276 /// paths than the ones selected).
278 /// Because the payment failed outright, no payment tracking is done and no
279 /// [`Event::PaymentPathFailed`] or [`Event::PaymentFailed`] events will be generated.
281 /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
282 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
284 crate::c_types::derived::CVec_APIErrorZ),
285 /// Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
286 /// yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
288 /// [`PaymentId`]: crate::ln::channelmanager::PaymentId
289 /// [`Event::PaymentSent`]: crate::events::Event::PaymentSent
290 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
292 /// Some paths that were attempted failed to send, though some paths may have succeeded. At least
293 /// some paths have irrevocably committed to the HTLC.
295 /// The results here are ordered the same as the paths in the route object that was passed to
298 /// Any entries that contain `Err(APIError::MonitorUpdateInprogress)` will send once a
299 /// [`MonitorEvent::Completed`] is provided for the next-hop channel with the latest update_id.
301 /// [`MonitorEvent::Completed`]: crate::chain::channelmonitor::MonitorEvent::Completed
303 /// The errors themselves, in the same order as the paths from the route.
304 results: crate::c_types::derived::CVec_CResult_NoneAPIErrorZZ,
305 /// If some paths failed without irrevocably committing to the new HTLC(s), this will
306 /// contain a [`RouteParameters`] object for the failing paths.
308 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
309 failed_paths_retry: crate::lightning::routing::router::RouteParameters,
310 /// The payment id for the payment, which is now at least partially pending.
311 payment_id: crate::c_types::ThirtyTwoBytes,
314 use lightning::ln::outbound_payment::PaymentSendFailure as PaymentSendFailureImport;
315 pub(crate) type nativePaymentSendFailure = PaymentSendFailureImport;
317 impl PaymentSendFailure {
319 pub(crate) fn to_native(&self) -> nativePaymentSendFailure {
321 PaymentSendFailure::ParameterError (ref a, ) => {
322 let mut a_nonref = Clone::clone(a);
323 nativePaymentSendFailure::ParameterError (
324 a_nonref.into_native(),
327 PaymentSendFailure::PathParameterError (ref a, ) => {
328 let mut a_nonref = Clone::clone(a);
329 let mut local_a_nonref = Vec::new(); for mut item in a_nonref.into_rust().drain(..) { local_a_nonref.push( { let mut local_a_nonref_0 = match item.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.err)) }).into_native() })}; local_a_nonref_0 }); };
330 nativePaymentSendFailure::PathParameterError (
334 PaymentSendFailure::AllFailedResendSafe (ref a, ) => {
335 let mut a_nonref = Clone::clone(a);
336 let mut local_a_nonref = Vec::new(); for mut item in a_nonref.into_rust().drain(..) { local_a_nonref.push( { item.into_native() }); };
337 nativePaymentSendFailure::AllFailedResendSafe (
341 PaymentSendFailure::DuplicatePayment => nativePaymentSendFailure::DuplicatePayment,
342 PaymentSendFailure::PartialFailure {ref results, ref failed_paths_retry, ref payment_id, } => {
343 let mut results_nonref = Clone::clone(results);
344 let mut local_results_nonref = Vec::new(); for mut item in results_nonref.into_rust().drain(..) { local_results_nonref.push( { let mut local_results_nonref_0 = match item.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.err)) }).into_native() })}; local_results_nonref_0 }); };
345 let mut failed_paths_retry_nonref = Clone::clone(failed_paths_retry);
346 let mut local_failed_paths_retry_nonref = if failed_paths_retry_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(failed_paths_retry_nonref.take_inner()) } }) };
347 let mut payment_id_nonref = Clone::clone(payment_id);
348 nativePaymentSendFailure::PartialFailure {
349 results: local_results_nonref,
350 failed_paths_retry: local_failed_paths_retry_nonref,
351 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
357 pub(crate) fn into_native(self) -> nativePaymentSendFailure {
359 PaymentSendFailure::ParameterError (mut a, ) => {
360 nativePaymentSendFailure::ParameterError (
364 PaymentSendFailure::PathParameterError (mut a, ) => {
365 let mut local_a = Vec::new(); for mut item in a.into_rust().drain(..) { local_a.push( { let mut local_a_0 = match item.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.err)) }).into_native() })}; local_a_0 }); };
366 nativePaymentSendFailure::PathParameterError (
370 PaymentSendFailure::AllFailedResendSafe (mut a, ) => {
371 let mut local_a = Vec::new(); for mut item in a.into_rust().drain(..) { local_a.push( { item.into_native() }); };
372 nativePaymentSendFailure::AllFailedResendSafe (
376 PaymentSendFailure::DuplicatePayment => nativePaymentSendFailure::DuplicatePayment,
377 PaymentSendFailure::PartialFailure {mut results, mut failed_paths_retry, mut payment_id, } => {
378 let mut local_results = Vec::new(); for mut item in results.into_rust().drain(..) { local_results.push( { let mut local_results_0 = match item.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut item.contents.err)) }).into_native() })}; local_results_0 }); };
379 let mut local_failed_paths_retry = if failed_paths_retry.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(failed_paths_retry.take_inner()) } }) };
380 nativePaymentSendFailure::PartialFailure {
381 results: local_results,
382 failed_paths_retry: local_failed_paths_retry,
383 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
389 pub(crate) fn from_native(native: &nativePaymentSendFailure) -> Self {
391 nativePaymentSendFailure::ParameterError (ref a, ) => {
392 let mut a_nonref = Clone::clone(a);
393 PaymentSendFailure::ParameterError (
394 crate::lightning::util::errors::APIError::native_into(a_nonref),
397 nativePaymentSendFailure::PathParameterError (ref a, ) => {
398 let mut a_nonref = Clone::clone(a);
399 let mut local_a_nonref = Vec::new(); for mut item in a_nonref.drain(..) { local_a_nonref.push( { let mut local_a_nonref_0 = match item { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() }; local_a_nonref_0 }); };
400 PaymentSendFailure::PathParameterError (
401 local_a_nonref.into(),
404 nativePaymentSendFailure::AllFailedResendSafe (ref a, ) => {
405 let mut a_nonref = Clone::clone(a);
406 let mut local_a_nonref = Vec::new(); for mut item in a_nonref.drain(..) { local_a_nonref.push( { crate::lightning::util::errors::APIError::native_into(item) }); };
407 PaymentSendFailure::AllFailedResendSafe (
408 local_a_nonref.into(),
411 nativePaymentSendFailure::DuplicatePayment => PaymentSendFailure::DuplicatePayment,
412 nativePaymentSendFailure::PartialFailure {ref results, ref failed_paths_retry, ref payment_id, } => {
413 let mut results_nonref = Clone::clone(results);
414 let mut local_results_nonref = Vec::new(); for mut item in results_nonref.drain(..) { local_results_nonref.push( { let mut local_results_nonref_0 = match item { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() }; local_results_nonref_0 }); };
415 let mut failed_paths_retry_nonref = Clone::clone(failed_paths_retry);
416 let mut local_failed_paths_retry_nonref = crate::lightning::routing::router::RouteParameters { inner: if failed_paths_retry_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((failed_paths_retry_nonref.unwrap())) } }, is_owned: true };
417 let mut payment_id_nonref = Clone::clone(payment_id);
418 PaymentSendFailure::PartialFailure {
419 results: local_results_nonref.into(),
420 failed_paths_retry: local_failed_paths_retry_nonref,
421 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
427 pub(crate) fn native_into(native: nativePaymentSendFailure) -> Self {
429 nativePaymentSendFailure::ParameterError (mut a, ) => {
430 PaymentSendFailure::ParameterError (
431 crate::lightning::util::errors::APIError::native_into(a),
434 nativePaymentSendFailure::PathParameterError (mut a, ) => {
435 let mut local_a = Vec::new(); for mut item in a.drain(..) { local_a.push( { let mut local_a_0 = match item { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() }; local_a_0 }); };
436 PaymentSendFailure::PathParameterError (
440 nativePaymentSendFailure::AllFailedResendSafe (mut a, ) => {
441 let mut local_a = Vec::new(); for mut item in a.drain(..) { local_a.push( { crate::lightning::util::errors::APIError::native_into(item) }); };
442 PaymentSendFailure::AllFailedResendSafe (
446 nativePaymentSendFailure::DuplicatePayment => PaymentSendFailure::DuplicatePayment,
447 nativePaymentSendFailure::PartialFailure {mut results, mut failed_paths_retry, mut payment_id, } => {
448 let mut local_results = Vec::new(); for mut item in results.drain(..) { local_results.push( { let mut local_results_0 = match item { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() }; local_results_0 }); };
449 let mut local_failed_paths_retry = crate::lightning::routing::router::RouteParameters { inner: if failed_paths_retry.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((failed_paths_retry.unwrap())) } }, is_owned: true };
450 PaymentSendFailure::PartialFailure {
451 results: local_results.into(),
452 failed_paths_retry: local_failed_paths_retry,
453 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
459 /// Frees any resources used by the PaymentSendFailure
461 pub extern "C" fn PaymentSendFailure_free(this_ptr: PaymentSendFailure) { }
462 /// Creates a copy of the PaymentSendFailure
464 pub extern "C" fn PaymentSendFailure_clone(orig: &PaymentSendFailure) -> PaymentSendFailure {
468 /// Utility method to constructs a new ParameterError-variant PaymentSendFailure
469 pub extern "C" fn PaymentSendFailure_parameter_error(a: crate::lightning::util::errors::APIError) -> PaymentSendFailure {
470 PaymentSendFailure::ParameterError(a, )
473 /// Utility method to constructs a new PathParameterError-variant PaymentSendFailure
474 pub extern "C" fn PaymentSendFailure_path_parameter_error(a: crate::c_types::derived::CVec_CResult_NoneAPIErrorZZ) -> PaymentSendFailure {
475 PaymentSendFailure::PathParameterError(a, )
478 /// Utility method to constructs a new AllFailedResendSafe-variant PaymentSendFailure
479 pub extern "C" fn PaymentSendFailure_all_failed_resend_safe(a: crate::c_types::derived::CVec_APIErrorZ) -> PaymentSendFailure {
480 PaymentSendFailure::AllFailedResendSafe(a, )
483 /// Utility method to constructs a new DuplicatePayment-variant PaymentSendFailure
484 pub extern "C" fn PaymentSendFailure_duplicate_payment() -> PaymentSendFailure {
485 PaymentSendFailure::DuplicatePayment}
487 /// Utility method to constructs a new PartialFailure-variant PaymentSendFailure
488 pub extern "C" fn PaymentSendFailure_partial_failure(results: crate::c_types::derived::CVec_CResult_NoneAPIErrorZZ, failed_paths_retry: crate::lightning::routing::router::RouteParameters, payment_id: crate::c_types::ThirtyTwoBytes) -> PaymentSendFailure {
489 PaymentSendFailure::PartialFailure {
495 /// Checks if two PaymentSendFailures contain equal inner contents.
496 /// This ignores pointers and is_owned flags and looks at the values in fields.
498 pub extern "C" fn PaymentSendFailure_eq(a: &PaymentSendFailure, b: &PaymentSendFailure) -> bool {
499 if &a.to_native() == &b.to_native() { true } else { false }
501 /// Indicates that we failed to send a payment probe. Further errors may be surfaced later via
502 /// [`Event::ProbeFailed`].
504 /// [`Event::ProbeFailed`]: crate::events::Event::ProbeFailed
508 pub enum ProbeSendFailure {
509 /// We were unable to find a route to the destination.
511 /// We failed to send the payment probes.
513 crate::lightning::ln::outbound_payment::PaymentSendFailure),
515 use lightning::ln::outbound_payment::ProbeSendFailure as ProbeSendFailureImport;
516 pub(crate) type nativeProbeSendFailure = ProbeSendFailureImport;
518 impl ProbeSendFailure {
520 pub(crate) fn to_native(&self) -> nativeProbeSendFailure {
522 ProbeSendFailure::RouteNotFound => nativeProbeSendFailure::RouteNotFound,
523 ProbeSendFailure::SendingFailed (ref a, ) => {
524 let mut a_nonref = Clone::clone(a);
525 nativeProbeSendFailure::SendingFailed (
526 a_nonref.into_native(),
532 pub(crate) fn into_native(self) -> nativeProbeSendFailure {
534 ProbeSendFailure::RouteNotFound => nativeProbeSendFailure::RouteNotFound,
535 ProbeSendFailure::SendingFailed (mut a, ) => {
536 nativeProbeSendFailure::SendingFailed (
543 pub(crate) fn from_native(native: &nativeProbeSendFailure) -> Self {
545 nativeProbeSendFailure::RouteNotFound => ProbeSendFailure::RouteNotFound,
546 nativeProbeSendFailure::SendingFailed (ref a, ) => {
547 let mut a_nonref = Clone::clone(a);
548 ProbeSendFailure::SendingFailed (
549 crate::lightning::ln::outbound_payment::PaymentSendFailure::native_into(a_nonref),
555 pub(crate) fn native_into(native: nativeProbeSendFailure) -> Self {
557 nativeProbeSendFailure::RouteNotFound => ProbeSendFailure::RouteNotFound,
558 nativeProbeSendFailure::SendingFailed (mut a, ) => {
559 ProbeSendFailure::SendingFailed (
560 crate::lightning::ln::outbound_payment::PaymentSendFailure::native_into(a),
566 /// Frees any resources used by the ProbeSendFailure
568 pub extern "C" fn ProbeSendFailure_free(this_ptr: ProbeSendFailure) { }
569 /// Creates a copy of the ProbeSendFailure
571 pub extern "C" fn ProbeSendFailure_clone(orig: &ProbeSendFailure) -> ProbeSendFailure {
575 /// Utility method to constructs a new RouteNotFound-variant ProbeSendFailure
576 pub extern "C" fn ProbeSendFailure_route_not_found() -> ProbeSendFailure {
577 ProbeSendFailure::RouteNotFound}
579 /// Utility method to constructs a new SendingFailed-variant ProbeSendFailure
580 pub extern "C" fn ProbeSendFailure_sending_failed(a: crate::lightning::ln::outbound_payment::PaymentSendFailure) -> ProbeSendFailure {
581 ProbeSendFailure::SendingFailed(a, )
583 /// Checks if two ProbeSendFailures contain equal inner contents.
584 /// This ignores pointers and is_owned flags and looks at the values in fields.
586 pub extern "C" fn ProbeSendFailure_eq(a: &ProbeSendFailure, b: &ProbeSendFailure) -> bool {
587 if &a.to_native() == &b.to_native() { true } else { false }
590 use lightning::ln::outbound_payment::RecipientOnionFields as nativeRecipientOnionFieldsImport;
591 pub(crate) type nativeRecipientOnionFields = nativeRecipientOnionFieldsImport;
593 /// Information which is provided, encrypted, to the payment recipient when sending HTLCs.
595 /// This should generally be constructed with data communicated to us from the recipient (via a
596 /// BOLT11 or BOLT12 invoice).
599 pub struct RecipientOnionFields {
600 /// A pointer to the opaque Rust object.
602 /// Nearly everywhere, inner must be non-null, however in places where
603 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
604 pub inner: *mut nativeRecipientOnionFields,
605 /// Indicates that this is the only struct which contains the same pointer.
607 /// Rust functions which take ownership of an object provided via an argument require
608 /// this to be true and invalidate the object pointed to by inner.
612 impl Drop for RecipientOnionFields {
614 if self.is_owned && !<*mut nativeRecipientOnionFields>::is_null(self.inner) {
615 let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
619 /// Frees any resources used by the RecipientOnionFields, if is_owned is set and inner is non-NULL.
621 pub extern "C" fn RecipientOnionFields_free(this_obj: RecipientOnionFields) { }
623 /// Used only if an object of this type is returned as a trait impl by a method
624 pub(crate) extern "C" fn RecipientOnionFields_free_void(this_ptr: *mut c_void) {
625 let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRecipientOnionFields) };
628 impl RecipientOnionFields {
629 pub(crate) fn get_native_ref(&self) -> &'static nativeRecipientOnionFields {
630 unsafe { &*ObjOps::untweak_ptr(self.inner) }
632 pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRecipientOnionFields {
633 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
635 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
636 pub(crate) fn take_inner(mut self) -> *mut nativeRecipientOnionFields {
637 assert!(self.is_owned);
638 let ret = ObjOps::untweak_ptr(self.inner);
639 self.inner = core::ptr::null_mut();
643 /// The [`PaymentSecret`] is an arbitrary 32 bytes provided by the recipient for us to repeat
644 /// in the onion. It is unrelated to `payment_hash` (or [`PaymentPreimage`]) and exists to
645 /// authenticate the sender to the recipient and prevent payment-probing (deanonymization)
648 /// If you do not have one, the [`Route`] you pay over must not contain multiple paths as
649 /// multi-path payments require a recipient-provided secret.
651 /// Some implementations may reject spontaneous payments with payment secrets, so you may only
652 /// want to provide a secret for a spontaneous payment if MPP is needed and you know your
653 /// recipient will not reject it.
655 pub extern "C" fn RecipientOnionFields_get_payment_secret(this_ptr: &RecipientOnionFields) -> crate::c_types::derived::COption_ThirtyTwoBytesZ {
656 let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_secret;
657 let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::c_types::ThirtyTwoBytes { data: (*inner_val.as_ref().unwrap()).clone().0 } }) };
660 /// The [`PaymentSecret`] is an arbitrary 32 bytes provided by the recipient for us to repeat
661 /// in the onion. It is unrelated to `payment_hash` (or [`PaymentPreimage`]) and exists to
662 /// authenticate the sender to the recipient and prevent payment-probing (deanonymization)
665 /// If you do not have one, the [`Route`] you pay over must not contain multiple paths as
666 /// multi-path payments require a recipient-provided secret.
668 /// Some implementations may reject spontaneous payments with payment secrets, so you may only
669 /// want to provide a secret for a spontaneous payment if MPP is needed and you know your
670 /// recipient will not reject it.
672 pub extern "C" fn RecipientOnionFields_set_payment_secret(this_ptr: &mut RecipientOnionFields, mut val: crate::c_types::derived::COption_ThirtyTwoBytesZ) {
673 let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentSecret({ val_opt.take() }.data) }})} };
674 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_secret = local_val;
676 /// The payment metadata serves a similar purpose as [`Self::payment_secret`] but is of
677 /// arbitrary length. This gives recipients substantially more flexibility to receive
680 /// In LDK, while the [`Self::payment_secret`] is fixed based on an internal authentication
681 /// scheme to authenticate received payments against expected payments and invoices, this field
682 /// is not used in LDK for received payments, and can be used to store arbitrary data in
683 /// invoices which will be received with the payment.
685 /// Note that this field was added to the lightning specification more recently than
686 /// [`Self::payment_secret`] and while nearly all lightning senders support secrets, metadata
687 /// may not be supported as universally.
689 /// Returns a copy of the field.
691 pub extern "C" fn RecipientOnionFields_get_payment_metadata(this_ptr: &RecipientOnionFields) -> crate::c_types::derived::COption_CVec_u8ZZ {
692 let mut inner_val = this_ptr.get_native_mut_ref().payment_metadata.clone();
693 let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_CVec_u8ZZ::None } else { crate::c_types::derived::COption_CVec_u8ZZ::Some( { let mut local_inner_val_0 = Vec::new(); for mut item in inner_val.unwrap().drain(..) { local_inner_val_0.push( { item }); }; local_inner_val_0.into() }) };
696 /// The payment metadata serves a similar purpose as [`Self::payment_secret`] but is of
697 /// arbitrary length. This gives recipients substantially more flexibility to receive
700 /// In LDK, while the [`Self::payment_secret`] is fixed based on an internal authentication
701 /// scheme to authenticate received payments against expected payments and invoices, this field
702 /// is not used in LDK for received payments, and can be used to store arbitrary data in
703 /// invoices which will be received with the payment.
705 /// Note that this field was added to the lightning specification more recently than
706 /// [`Self::payment_secret`] and while nearly all lightning senders support secrets, metadata
707 /// may not be supported as universally.
709 pub extern "C" fn RecipientOnionFields_set_payment_metadata(this_ptr: &mut RecipientOnionFields, mut val: crate::c_types::derived::COption_CVec_u8ZZ) {
710 let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { let mut local_val_0 = Vec::new(); for mut item in { val_opt.take() }.into_rust().drain(..) { local_val_0.push( { item }); }; local_val_0 }})} };
711 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_metadata = local_val;
713 impl Clone for RecipientOnionFields {
714 fn clone(&self) -> Self {
716 inner: if <*mut nativeRecipientOnionFields>::is_null(self.inner) { core::ptr::null_mut() } else {
717 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
723 /// Used only if an object of this type is returned as a trait impl by a method
724 pub(crate) extern "C" fn RecipientOnionFields_clone_void(this_ptr: *const c_void) -> *mut c_void {
725 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRecipientOnionFields)).clone() })) as *mut c_void
728 /// Creates a copy of the RecipientOnionFields
729 pub extern "C" fn RecipientOnionFields_clone(orig: &RecipientOnionFields) -> RecipientOnionFields {
732 /// Checks if two RecipientOnionFieldss contain equal inner contents.
733 /// This ignores pointers and is_owned flags and looks at the values in fields.
734 /// Two objects with NULL inner values will be considered "equal" here.
736 pub extern "C" fn RecipientOnionFields_eq(a: &RecipientOnionFields, b: &RecipientOnionFields) -> bool {
737 if a.inner == b.inner { return true; }
738 if a.inner.is_null() || b.inner.is_null() { return false; }
739 if a.get_native_ref() == b.get_native_ref() { true } else { false }
742 /// Serialize the RecipientOnionFields object into a byte array which can be read by RecipientOnionFields_read
743 pub extern "C" fn RecipientOnionFields_write(obj: &crate::lightning::ln::outbound_payment::RecipientOnionFields) -> crate::c_types::derived::CVec_u8Z {
744 crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
747 pub(crate) extern "C" fn RecipientOnionFields_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
748 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRecipientOnionFields) })
751 /// Read a RecipientOnionFields from a byte array, created by RecipientOnionFields_write
752 pub extern "C" fn RecipientOnionFields_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RecipientOnionFieldsDecodeErrorZ {
753 let res: Result<lightning::ln::outbound_payment::RecipientOnionFields, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
754 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
757 /// Creates a [`RecipientOnionFields`] from only a [`PaymentSecret`]. This is the most common
758 /// set of onion fields for today's BOLT11 invoices - most nodes require a [`PaymentSecret`]
759 /// but do not require or provide any further data.
762 pub extern "C" fn RecipientOnionFields_secret_only(mut payment_secret: crate::c_types::ThirtyTwoBytes) -> crate::lightning::ln::outbound_payment::RecipientOnionFields {
763 let mut ret = lightning::ln::outbound_payment::RecipientOnionFields::secret_only(::lightning::ln::PaymentSecret(payment_secret.data));
764 crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: ObjOps::heap_alloc(ret), is_owned: true }
767 /// Creates a new [`RecipientOnionFields`] with no fields. This generally does not create
768 /// payable HTLCs except for single-path spontaneous payments, i.e. this should generally
769 /// only be used for calls to [`ChannelManager::send_spontaneous_payment`]. If you are sending
770 /// a spontaneous MPP this will not work as all MPP require payment secrets; you may
771 /// instead want to use [`RecipientOnionFields::secret_only`].
773 /// [`ChannelManager::send_spontaneous_payment`]: super::channelmanager::ChannelManager::send_spontaneous_payment
774 /// [`RecipientOnionFields::secret_only`]: RecipientOnionFields::secret_only
777 pub extern "C" fn RecipientOnionFields_spontaneous_empty() -> crate::lightning::ln::outbound_payment::RecipientOnionFields {
778 let mut ret = lightning::ln::outbound_payment::RecipientOnionFields::spontaneous_empty();
779 crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: ObjOps::heap_alloc(ret), is_owned: true }
782 /// Creates a new [`RecipientOnionFields`] from an existing one, adding custom TLVs. Each
783 /// TLV is provided as a `(u64, Vec<u8>)` for the type number and serialized value
784 /// respectively. TLV type numbers must be unique and within the range
785 /// reserved for custom types, i.e. >= 2^16, otherwise this method will return `Err(())`.
787 /// This method will also error for types in the experimental range which have been
788 /// standardized within the protocol, which only includes 5482373484 (keysend) for now.
790 /// See [`Self::custom_tlvs`] for more info.
793 pub extern "C" fn RecipientOnionFields_with_custom_tlvs(mut this_arg: crate::lightning::ln::outbound_payment::RecipientOnionFields, mut custom_tlvs: crate::c_types::derived::CVec_C2Tuple_u64CVec_u8ZZZ) -> crate::c_types::derived::CResult_RecipientOnionFieldsNoneZ {
794 let mut local_custom_tlvs = Vec::new(); for mut item in custom_tlvs.into_rust().drain(..) { local_custom_tlvs.push( { let (mut orig_custom_tlvs_0_0, mut orig_custom_tlvs_0_1) = item.to_rust(); let mut local_orig_custom_tlvs_0_1 = Vec::new(); for mut item in orig_custom_tlvs_0_1.into_rust().drain(..) { local_orig_custom_tlvs_0_1.push( { item }); }; let mut local_custom_tlvs_0 = (orig_custom_tlvs_0_0, local_orig_custom_tlvs_0_1); local_custom_tlvs_0 }); };
795 let mut ret = (*unsafe { Box::from_raw(this_arg.take_inner()) }).with_custom_tlvs(local_custom_tlvs);
796 let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { () /*e*/ }).into() };
800 /// Gets the custom TLVs that will be sent or have been received.
802 /// Custom TLVs allow sending extra application-specific data with a payment. They provide
803 /// additional flexibility on top of payment metadata, as while other implementations may
804 /// require `payment_metadata` to reflect metadata provided in an invoice, custom TLVs
805 /// do not have this restriction.
807 /// Note that if this field is non-empty, it will contain strictly increasing TLVs, each
808 /// represented by a `(u64, Vec<u8>)` for its type number and serialized value respectively.
809 /// This is validated when setting this field using [`Self::with_custom_tlvs`].
812 pub extern "C" fn RecipientOnionFields_custom_tlvs(this_arg: &crate::lightning::ln::outbound_payment::RecipientOnionFields) -> crate::c_types::derived::CVec_C2Tuple_u64CVec_u8ZZZ {
813 let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.custom_tlvs();
814 let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1) = item; let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.drain(..) { local_orig_ret_0_1.push( { item }); }; let mut local_ret_0 = (orig_ret_0_0, local_orig_ret_0_1.into()).into(); local_ret_0 }); };