//! [`Event`]: crate::events::Event
use alloc::str::FromStr;
+use alloc::string::String;
use core::ffi::c_void;
use core::convert::Infallible;
use bitcoin::hashes::Hash;
use alloc::{vec::Vec, boxed::Box};
-use lightning::events::bump_transaction::ChannelDerivationParameters as nativeChannelDerivationParametersImport;
-pub(crate) type nativeChannelDerivationParameters = nativeChannelDerivationParametersImport;
-
-/// The parameters required to derive a channel signer via [`SignerProvider`].
-#[must_use]
-#[repr(C)]
-pub struct ChannelDerivationParameters {
- /// A pointer to the opaque Rust object.
-
- /// Nearly everywhere, inner must be non-null, however in places where
- /// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeChannelDerivationParameters,
- /// Indicates that this is the only struct which contains the same pointer.
-
- /// Rust functions which take ownership of an object provided via an argument require
- /// this to be true and invalidate the object pointed to by inner.
- pub is_owned: bool,
-}
-
-impl Drop for ChannelDerivationParameters {
- fn drop(&mut self) {
- if self.is_owned && !<*mut nativeChannelDerivationParameters>::is_null(self.inner) {
- let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
- }
- }
-}
-/// Frees any resources used by the ChannelDerivationParameters, if is_owned is set and inner is non-NULL.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_free(this_obj: ChannelDerivationParameters) { }
-#[allow(unused)]
-/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn ChannelDerivationParameters_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeChannelDerivationParameters) };
-}
-#[allow(unused)]
-impl ChannelDerivationParameters {
- pub(crate) fn get_native_ref(&self) -> &'static nativeChannelDerivationParameters {
- unsafe { &*ObjOps::untweak_ptr(self.inner) }
- }
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelDerivationParameters {
- unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
- }
- /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeChannelDerivationParameters {
- assert!(self.is_owned);
- let ret = ObjOps::untweak_ptr(self.inner);
- self.inner = core::ptr::null_mut();
- ret
- }
-}
-/// The value in satoshis of the channel we're attempting to spend the anchor output of.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_get_value_satoshis(this_ptr: &ChannelDerivationParameters) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().value_satoshis;
- *inner_val
-}
-/// The value in satoshis of the channel we're attempting to spend the anchor output of.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_set_value_satoshis(this_ptr: &mut ChannelDerivationParameters, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.value_satoshis = val;
-}
-/// The unique identifier to re-derive the signer for the associated channel.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_get_keys_id(this_ptr: &ChannelDerivationParameters) -> *const [u8; 32] {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().keys_id;
- inner_val
-}
-/// The unique identifier to re-derive the signer for the associated channel.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_set_keys_id(this_ptr: &mut ChannelDerivationParameters, mut val: crate::c_types::ThirtyTwoBytes) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.keys_id = val.data;
-}
-/// The necessary channel parameters that need to be provided to the re-derived signer through
-/// [`ChannelSigner::provide_channel_parameters`].
-///
-/// [`ChannelSigner::provide_channel_parameters`]: crate::sign::ChannelSigner::provide_channel_parameters
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_get_transaction_parameters(this_ptr: &ChannelDerivationParameters) -> crate::lightning::ln::chan_utils::ChannelTransactionParameters {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().transaction_parameters;
- crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::chan_utils::ChannelTransactionParameters<>) as *mut _) }, is_owned: false }
-}
-/// The necessary channel parameters that need to be provided to the re-derived signer through
-/// [`ChannelSigner::provide_channel_parameters`].
-///
-/// [`ChannelSigner::provide_channel_parameters`]: crate::sign::ChannelSigner::provide_channel_parameters
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_set_transaction_parameters(this_ptr: &mut ChannelDerivationParameters, mut val: crate::lightning::ln::chan_utils::ChannelTransactionParameters) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.transaction_parameters = *unsafe { Box::from_raw(val.take_inner()) };
-}
-/// Constructs a new ChannelDerivationParameters given each field
-#[must_use]
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_new(mut value_satoshis_arg: u64, mut keys_id_arg: crate::c_types::ThirtyTwoBytes, mut transaction_parameters_arg: crate::lightning::ln::chan_utils::ChannelTransactionParameters) -> ChannelDerivationParameters {
- ChannelDerivationParameters { inner: ObjOps::heap_alloc(nativeChannelDerivationParameters {
- value_satoshis: value_satoshis_arg,
- keys_id: keys_id_arg.data,
- transaction_parameters: *unsafe { Box::from_raw(transaction_parameters_arg.take_inner()) },
- }), is_owned: true }
-}
-impl Clone for ChannelDerivationParameters {
- fn clone(&self) -> Self {
- Self {
- inner: if <*mut nativeChannelDerivationParameters>::is_null(self.inner) { core::ptr::null_mut() } else {
- ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
- is_owned: true,
- }
- }
-}
-#[allow(unused)]
-/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn ChannelDerivationParameters_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelDerivationParameters)).clone() })) as *mut c_void
-}
-#[no_mangle]
-/// Creates a copy of the ChannelDerivationParameters
-pub extern "C" fn ChannelDerivationParameters_clone(orig: &ChannelDerivationParameters) -> ChannelDerivationParameters {
- orig.clone()
-}
-/// Checks if two ChannelDerivationParameterss contain equal inner contents.
-/// This ignores pointers and is_owned flags and looks at the values in fields.
-/// Two objects with NULL inner values will be considered "equal" here.
-#[no_mangle]
-pub extern "C" fn ChannelDerivationParameters_eq(a: &ChannelDerivationParameters, b: &ChannelDerivationParameters) -> bool {
- if a.inner == b.inner { return true; }
- if a.inner.is_null() || b.inner.is_null() { return false; }
- if a.get_native_ref() == b.get_native_ref() { true } else { false }
-}
-
use lightning::events::bump_transaction::AnchorDescriptor as nativeAnchorDescriptorImport;
pub(crate) type nativeAnchorDescriptor = nativeAnchorDescriptorImport;
}
/// The parameters required to derive the signer for the anchor input.
#[no_mangle]
-pub extern "C" fn AnchorDescriptor_get_channel_derivation_parameters(this_ptr: &AnchorDescriptor) -> crate::lightning::events::bump_transaction::ChannelDerivationParameters {
+pub extern "C" fn AnchorDescriptor_get_channel_derivation_parameters(this_ptr: &AnchorDescriptor) -> crate::lightning::sign::ChannelDerivationParameters {
let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_derivation_parameters;
- crate::lightning::events::bump_transaction::ChannelDerivationParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::events::bump_transaction::ChannelDerivationParameters<>) as *mut _) }, is_owned: false }
+ crate::lightning::sign::ChannelDerivationParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::sign::ChannelDerivationParameters<>) as *mut _) }, is_owned: false }
}
/// The parameters required to derive the signer for the anchor input.
#[no_mangle]
-pub extern "C" fn AnchorDescriptor_set_channel_derivation_parameters(this_ptr: &mut AnchorDescriptor, mut val: crate::lightning::events::bump_transaction::ChannelDerivationParameters) {
+pub extern "C" fn AnchorDescriptor_set_channel_derivation_parameters(this_ptr: &mut AnchorDescriptor, mut val: crate::lightning::sign::ChannelDerivationParameters) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_derivation_parameters = *unsafe { Box::from_raw(val.take_inner()) };
}
/// The transaction input's outpoint corresponding to the commitment transaction's anchor
/// Constructs a new AnchorDescriptor given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn AnchorDescriptor_new(mut channel_derivation_parameters_arg: crate::lightning::events::bump_transaction::ChannelDerivationParameters, mut outpoint_arg: crate::lightning::chain::transaction::OutPoint) -> AnchorDescriptor {
+pub extern "C" fn AnchorDescriptor_new(mut channel_derivation_parameters_arg: crate::lightning::sign::ChannelDerivationParameters, mut outpoint_arg: crate::lightning::chain::transaction::OutPoint) -> AnchorDescriptor {
AnchorDescriptor { inner: ObjOps::heap_alloc(nativeAnchorDescriptor {
channel_derivation_parameters: *unsafe { Box::from_raw(channel_derivation_parameters_arg.take_inner()) },
outpoint: crate::c_types::C_to_bitcoin_outpoint(outpoint_arg),
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn AnchorDescriptor_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAnchorDescriptor)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeAnchorDescriptor)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the AnchorDescriptor
pub extern "C" fn AnchorDescriptor_clone(orig: &AnchorDescriptor) -> AnchorDescriptor {
orig.clone()
}
+/// Get a string which allows debug introspection of a AnchorDescriptor object
+pub extern "C" fn AnchorDescriptor_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::bump_transaction::AnchorDescriptor }).into()}
/// Checks if two AnchorDescriptors contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
#[no_mangle]
pub extern "C" fn AnchorDescriptor_witness_script(this_arg: &crate::lightning::events::bump_transaction::AnchorDescriptor) -> crate::c_types::derived::CVec_u8Z {
let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.witness_script();
- ret.into_bytes().into()
+ ret.to_bytes().into()
}
/// Returns the fully signed witness required to spend the anchor output in the commitment
/// transaction.
#[must_use]
#[no_mangle]
-pub extern "C" fn AnchorDescriptor_tx_input_witness(this_arg: &crate::lightning::events::bump_transaction::AnchorDescriptor, mut signature: crate::c_types::Signature) -> crate::c_types::Witness {
+pub extern "C" fn AnchorDescriptor_tx_input_witness(this_arg: &crate::lightning::events::bump_transaction::AnchorDescriptor, mut signature: crate::c_types::ECDSASignature) -> crate::c_types::Witness {
let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.tx_input_witness(&signature.into_rust());
crate::c_types::Witness::from_bitcoin(&ret)
}
/// Derives the channel signer required to sign the anchor input.
#[must_use]
#[no_mangle]
-pub extern "C" fn AnchorDescriptor_derive_channel_signer(this_arg: &crate::lightning::events::bump_transaction::AnchorDescriptor, signer_provider: &crate::lightning::sign::SignerProvider) -> crate::lightning::sign::WriteableEcdsaChannelSigner {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.derive_channel_signer(signer_provider);
- Into::into(ret)
-}
-
-
-use lightning::events::bump_transaction::HTLCDescriptor as nativeHTLCDescriptorImport;
-pub(crate) type nativeHTLCDescriptor = nativeHTLCDescriptorImport;
-
-/// A descriptor used to sign for a commitment transaction's HTLC output.
-#[must_use]
-#[repr(C)]
-pub struct HTLCDescriptor {
- /// A pointer to the opaque Rust object.
-
- /// Nearly everywhere, inner must be non-null, however in places where
- /// the Rust equivalent takes an Option, it may be set to null to indicate None.
- pub inner: *mut nativeHTLCDescriptor,
- /// Indicates that this is the only struct which contains the same pointer.
-
- /// Rust functions which take ownership of an object provided via an argument require
- /// this to be true and invalidate the object pointed to by inner.
- pub is_owned: bool,
-}
-
-impl Drop for HTLCDescriptor {
- fn drop(&mut self) {
- if self.is_owned && !<*mut nativeHTLCDescriptor>::is_null(self.inner) {
- let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
- }
- }
-}
-/// Frees any resources used by the HTLCDescriptor, if is_owned is set and inner is non-NULL.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_free(this_obj: HTLCDescriptor) { }
-#[allow(unused)]
-/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn HTLCDescriptor_free_void(this_ptr: *mut c_void) {
- let _ = unsafe { Box::from_raw(this_ptr as *mut nativeHTLCDescriptor) };
-}
-#[allow(unused)]
-impl HTLCDescriptor {
- pub(crate) fn get_native_ref(&self) -> &'static nativeHTLCDescriptor {
- unsafe { &*ObjOps::untweak_ptr(self.inner) }
- }
- pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeHTLCDescriptor {
- unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
- }
- /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
- pub(crate) fn take_inner(mut self) -> *mut nativeHTLCDescriptor {
- assert!(self.is_owned);
- let ret = ObjOps::untweak_ptr(self.inner);
- self.inner = core::ptr::null_mut();
- ret
- }
-}
-/// The parameters required to derive the signer for the HTLC input.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_channel_derivation_parameters(this_ptr: &HTLCDescriptor) -> crate::lightning::events::bump_transaction::ChannelDerivationParameters {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_derivation_parameters;
- crate::lightning::events::bump_transaction::ChannelDerivationParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::events::bump_transaction::ChannelDerivationParameters<>) as *mut _) }, is_owned: false }
-}
-/// The parameters required to derive the signer for the HTLC input.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_channel_derivation_parameters(this_ptr: &mut HTLCDescriptor, mut val: crate::lightning::events::bump_transaction::ChannelDerivationParameters) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_derivation_parameters = *unsafe { Box::from_raw(val.take_inner()) };
-}
-/// The number of the commitment transaction in which the HTLC output lives.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_per_commitment_number(this_ptr: &HTLCDescriptor) -> u64 {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().per_commitment_number;
- *inner_val
-}
-/// The number of the commitment transaction in which the HTLC output lives.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_per_commitment_number(this_ptr: &mut HTLCDescriptor, mut val: u64) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.per_commitment_number = val;
-}
-/// The key tweak corresponding to the number of the commitment transaction in which the HTLC
-/// output lives. This tweak is applied to all the basepoints for both parties in the channel to
-/// arrive at unique keys per commitment.
-///
-/// See <https://github.com/lightning/bolts/blob/master/03-transactions.md#keys> for more info.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_per_commitment_point(this_ptr: &HTLCDescriptor) -> crate::c_types::PublicKey {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().per_commitment_point;
- crate::c_types::PublicKey::from_rust(&inner_val)
-}
-/// The key tweak corresponding to the number of the commitment transaction in which the HTLC
-/// output lives. This tweak is applied to all the basepoints for both parties in the channel to
-/// arrive at unique keys per commitment.
-///
-/// See <https://github.com/lightning/bolts/blob/master/03-transactions.md#keys> for more info.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_per_commitment_point(this_ptr: &mut HTLCDescriptor, mut val: crate::c_types::PublicKey) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.per_commitment_point = val.into_rust();
-}
-/// The details of the HTLC as it appears in the commitment transaction.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_htlc(this_ptr: &HTLCDescriptor) -> crate::lightning::ln::chan_utils::HTLCOutputInCommitment {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc;
- crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::chan_utils::HTLCOutputInCommitment<>) as *mut _) }, is_owned: false }
-}
-/// The details of the HTLC as it appears in the commitment transaction.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_htlc(this_ptr: &mut HTLCDescriptor, mut val: crate::lightning::ln::chan_utils::HTLCOutputInCommitment) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc = *unsafe { Box::from_raw(val.take_inner()) };
-}
-/// The preimage, if `Some`, to claim the HTLC output with. If `None`, the timeout path must be
-/// taken.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_preimage(this_ptr: &HTLCDescriptor) -> crate::c_types::derived::COption_PaymentPreimageZ {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().preimage;
- let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_PaymentPreimageZ::None } else { crate::c_types::derived::COption_PaymentPreimageZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::c_types::ThirtyTwoBytes { data: (*inner_val.as_ref().unwrap()).clone().0 } }) };
- local_inner_val
-}
-/// The preimage, if `Some`, to claim the HTLC output with. If `None`, the timeout path must be
-/// taken.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_preimage(this_ptr: &mut HTLCDescriptor, mut val: crate::c_types::derived::COption_PaymentPreimageZ) {
- let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentPreimage({ val_opt.take() }.data) }})} };
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.preimage = local_val;
-}
-/// The counterparty's signature required to spend the HTLC output.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_get_counterparty_sig(this_ptr: &HTLCDescriptor) -> crate::c_types::Signature {
- let mut inner_val = &mut this_ptr.get_native_mut_ref().counterparty_sig;
- crate::c_types::Signature::from_rust(&inner_val)
-}
-/// The counterparty's signature required to spend the HTLC output.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_set_counterparty_sig(this_ptr: &mut HTLCDescriptor, mut val: crate::c_types::Signature) {
- unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.counterparty_sig = val.into_rust();
-}
-impl Clone for HTLCDescriptor {
- fn clone(&self) -> Self {
- Self {
- inner: if <*mut nativeHTLCDescriptor>::is_null(self.inner) { core::ptr::null_mut() } else {
- ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
- is_owned: true,
- }
- }
-}
-#[allow(unused)]
-/// Used only if an object of this type is returned as a trait impl by a method
-pub(crate) extern "C" fn HTLCDescriptor_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeHTLCDescriptor)).clone() })) as *mut c_void
-}
-#[no_mangle]
-/// Creates a copy of the HTLCDescriptor
-pub extern "C" fn HTLCDescriptor_clone(orig: &HTLCDescriptor) -> HTLCDescriptor {
- orig.clone()
-}
-/// Checks if two HTLCDescriptors contain equal inner contents.
-/// This ignores pointers and is_owned flags and looks at the values in fields.
-/// Two objects with NULL inner values will be considered "equal" here.
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_eq(a: &HTLCDescriptor, b: &HTLCDescriptor) -> bool {
- if a.inner == b.inner { return true; }
- if a.inner.is_null() || b.inner.is_null() { return false; }
- if a.get_native_ref() == b.get_native_ref() { true } else { false }
-}
-/// Returns the outpoint of the HTLC output in the commitment transaction. This is the outpoint
-/// being spent by the HTLC input in the HTLC transaction.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_outpoint(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor) -> crate::lightning::chain::transaction::OutPoint {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.outpoint();
- crate::c_types::bitcoin_to_C_outpoint(&ret)
-}
-
-/// Returns the UTXO to be spent by the HTLC input, which can be obtained via
-/// [`Self::unsigned_tx_input`].
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_previous_utxo(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor) -> crate::c_types::TxOut {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.previous_utxo(secp256k1::global::SECP256K1);
- crate::c_types::TxOut::from_rust(&ret)
-}
-
-/// Returns the unsigned transaction input spending the HTLC output in the commitment
-/// transaction.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_unsigned_tx_input(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor) -> crate::c_types::TxIn {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.unsigned_tx_input();
- crate::c_types::TxIn::from_rust(&ret)
-}
-
-/// Returns the delayed output created as a result of spending the HTLC output in the commitment
-/// transaction.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_tx_output(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor) -> crate::c_types::TxOut {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.tx_output(secp256k1::global::SECP256K1);
- crate::c_types::TxOut::from_rust(&ret)
-}
-
-/// Returns the witness script of the HTLC output in the commitment transaction.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_witness_script(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor) -> crate::c_types::derived::CVec_u8Z {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.witness_script(secp256k1::global::SECP256K1);
- ret.into_bytes().into()
-}
-
-/// Returns the fully signed witness required to spend the HTLC output in the commitment
-/// transaction.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_tx_input_witness(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor, mut signature: crate::c_types::Signature, mut witness_script: crate::c_types::u8slice) -> crate::c_types::Witness {
- let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.tx_input_witness(&signature.into_rust(), &::bitcoin::blockdata::script::Script::from(Vec::from(witness_script.to_slice())));
- crate::c_types::Witness::from_bitcoin(&ret)
-}
-
-/// Derives the channel signer required to sign the HTLC input.
-#[must_use]
-#[no_mangle]
-pub extern "C" fn HTLCDescriptor_derive_channel_signer(this_arg: &crate::lightning::events::bump_transaction::HTLCDescriptor, signer_provider: &crate::lightning::sign::SignerProvider) -> crate::lightning::sign::WriteableEcdsaChannelSigner {
+pub extern "C" fn AnchorDescriptor_derive_channel_signer(this_arg: &crate::lightning::events::bump_transaction::AnchorDescriptor, signer_provider: &crate::lightning::sign::SignerProvider) -> crate::lightning::sign::ecdsa::WriteableEcdsaChannelSigner {
let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.derive_channel_signer(signer_provider);
Into::into(ret)
}
/// an empty `pending_htlcs`), confirmation of the commitment transaction can be considered to
/// be not urgent.
///
- /// [`EcdsaChannelSigner`]: crate::sign::EcdsaChannelSigner
- /// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::sign::EcdsaChannelSigner::sign_holder_anchor_input
+ /// [`EcdsaChannelSigner`]: crate::sign::ecdsa::EcdsaChannelSigner
+ /// [`EcdsaChannelSigner::sign_holder_anchor_input`]: crate::sign::ecdsa::EcdsaChannelSigner::sign_holder_anchor_input
/// [`build_anchor_input_witness`]: crate::ln::chan_utils::build_anchor_input_witness
ChannelClose {
/// The unique identifier for the claim of the anchor output in the commitment transaction.
/// longer able to commit external confirmed funds to the HTLC transaction or the fee committed
/// to the HTLC transaction is greater in value than the HTLCs being claimed.
///
- /// [`EcdsaChannelSigner`]: crate::sign::EcdsaChannelSigner
- /// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::sign::EcdsaChannelSigner::sign_holder_htlc_transaction
- /// [`HTLCDescriptor::tx_input_witness`]: HTLCDescriptor::tx_input_witness
+ /// [`EcdsaChannelSigner`]: crate::sign::ecdsa::EcdsaChannelSigner
+ /// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::sign::ecdsa::EcdsaChannelSigner::sign_holder_htlc_transaction
HTLCResolution {
/// The unique identifier for the claim of the HTLCs in the confirmed commitment
/// transaction.
claim_id: ::lightning::chain::ClaimId(claim_id_nonref.data),
target_feerate_sat_per_1000_weight: target_feerate_sat_per_1000_weight_nonref,
htlc_descriptors: local_htlc_descriptors_nonref,
- tx_lock_time: ::bitcoin::PackedLockTime(tx_lock_time_nonref),
+ tx_lock_time: ::bitcoin::blockdata::locktime::absolute::LockTime::from_consensus(tx_lock_time_nonref),
}
},
}
claim_id: ::lightning::chain::ClaimId(claim_id.data),
target_feerate_sat_per_1000_weight: target_feerate_sat_per_1000_weight,
htlc_descriptors: local_htlc_descriptors,
- tx_lock_time: ::bitcoin::PackedLockTime(tx_lock_time),
+ tx_lock_time: ::bitcoin::blockdata::locktime::absolute::LockTime::from_consensus(tx_lock_time),
}
},
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeBumpTransactionEvent) -> Self {
+ pub(crate) fn from_native(native: &BumpTransactionEventImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeBumpTransactionEvent) };
match native {
nativeBumpTransactionEvent::ChannelClose {ref claim_id, ref package_target_feerate_sat_per_1000_weight, ref commitment_tx, ref commitment_tx_fee_satoshis, ref anchor_descriptor, ref pending_htlcs, } => {
let mut claim_id_nonref = Clone::clone(claim_id);
let mut claim_id_nonref = Clone::clone(claim_id);
let mut target_feerate_sat_per_1000_weight_nonref = Clone::clone(target_feerate_sat_per_1000_weight);
let mut htlc_descriptors_nonref = Clone::clone(htlc_descriptors);
- let mut local_htlc_descriptors_nonref = Vec::new(); for mut item in htlc_descriptors_nonref.drain(..) { local_htlc_descriptors_nonref.push( { crate::lightning::events::bump_transaction::HTLCDescriptor { inner: ObjOps::heap_alloc(item), is_owned: true } }); };
+ let mut local_htlc_descriptors_nonref = Vec::new(); for mut item in htlc_descriptors_nonref.drain(..) { local_htlc_descriptors_nonref.push( { crate::lightning::sign::HTLCDescriptor { inner: ObjOps::heap_alloc(item), is_owned: true } }); };
let mut tx_lock_time_nonref = Clone::clone(tx_lock_time);
BumpTransactionEvent::HTLCResolution {
claim_id: crate::c_types::ThirtyTwoBytes { data: claim_id_nonref.0 },
target_feerate_sat_per_1000_weight: target_feerate_sat_per_1000_weight_nonref,
htlc_descriptors: local_htlc_descriptors_nonref.into(),
- tx_lock_time: tx_lock_time_nonref.0,
+ tx_lock_time: tx_lock_time_nonref.to_consensus_u32(),
}
},
}
}
},
nativeBumpTransactionEvent::HTLCResolution {mut claim_id, mut target_feerate_sat_per_1000_weight, mut htlc_descriptors, mut tx_lock_time, } => {
- let mut local_htlc_descriptors = Vec::new(); for mut item in htlc_descriptors.drain(..) { local_htlc_descriptors.push( { crate::lightning::events::bump_transaction::HTLCDescriptor { inner: ObjOps::heap_alloc(item), is_owned: true } }); };
+ let mut local_htlc_descriptors = Vec::new(); for mut item in htlc_descriptors.drain(..) { local_htlc_descriptors.push( { crate::lightning::sign::HTLCDescriptor { inner: ObjOps::heap_alloc(item), is_owned: true } }); };
BumpTransactionEvent::HTLCResolution {
claim_id: crate::c_types::ThirtyTwoBytes { data: claim_id.0 },
target_feerate_sat_per_1000_weight: target_feerate_sat_per_1000_weight,
htlc_descriptors: local_htlc_descriptors.into(),
- tx_lock_time: tx_lock_time.0,
+ tx_lock_time: tx_lock_time.to_consensus_u32(),
}
},
}
pub extern "C" fn BumpTransactionEvent_clone(orig: &BumpTransactionEvent) -> BumpTransactionEvent {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn BumpTransactionEvent_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const BumpTransactionEvent)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn BumpTransactionEvent_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut BumpTransactionEvent) };
+}
#[no_mangle]
/// Utility method to constructs a new ChannelClose-variant BumpTransactionEvent
pub extern "C" fn BumpTransactionEvent_channel_close(claim_id: crate::c_types::ThirtyTwoBytes, package_target_feerate_sat_per_1000_weight: u32, commitment_tx: crate::c_types::Transaction, commitment_tx_fee_satoshis: u64, anchor_descriptor: crate::lightning::events::bump_transaction::AnchorDescriptor, pending_htlcs: crate::c_types::derived::CVec_HTLCOutputInCommitmentZ) -> BumpTransactionEvent {
tx_lock_time,
}
}
+/// Get a string which allows debug introspection of a BumpTransactionEvent object
+pub extern "C" fn BumpTransactionEvent_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::bump_transaction::BumpTransactionEvent }).into()}
/// Checks if two BumpTransactionEvents contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn Input_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInput)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeInput)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the Input
pub extern "C" fn Input_clone(orig: &Input) -> Input {
orig.clone()
}
+/// Get a string which allows debug introspection of a Input object
+pub extern "C" fn Input_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::bump_transaction::Input }).into()}
/// Generates a non-cryptographic 64-bit hash of the Input.
#[no_mangle]
pub extern "C" fn Input_hash(o: &Input) -> u64 {
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn Utxo_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUtxo)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUtxo)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the Utxo
pub extern "C" fn Utxo_clone(orig: &Utxo) -> Utxo {
orig.clone()
}
+/// Get a string which allows debug introspection of a Utxo object
+pub extern "C" fn Utxo_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::bump_transaction::Utxo }).into()}
/// Generates a non-cryptographic 64-bit hash of the Utxo.
#[no_mangle]
pub extern "C" fn Utxo_hash(o: &Utxo) -> u64 {
#[must_use]
#[no_mangle]
pub extern "C" fn Utxo_new_p2pkh(mut outpoint: crate::lightning::chain::transaction::OutPoint, mut value: u64, pubkey_hash: *const [u8; 20]) -> crate::lightning::events::bump_transaction::Utxo {
- let mut ret = lightning::events::bump_transaction::Utxo::new_p2pkh(crate::c_types::C_to_bitcoin_outpoint(outpoint), value, &bitcoin::hash_types::PubkeyHash::from_hash(bitcoin::hashes::Hash::from_inner(unsafe { *pubkey_hash }.clone())));
+ let mut ret = lightning::events::bump_transaction::Utxo::new_p2pkh(crate::c_types::C_to_bitcoin_outpoint(outpoint), value, &bitcoin::hash_types::PubkeyHash::from_raw_hash(bitcoin::hashes::Hash::from_byte_array(unsafe { *pubkey_hash }.clone())));
crate::lightning::events::bump_transaction::Utxo { inner: ObjOps::heap_alloc(ret), is_owned: true }
}
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn CoinSelection_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCoinSelection)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeCoinSelection)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the CoinSelection
pub extern "C" fn CoinSelection_clone(orig: &CoinSelection) -> CoinSelection {
orig.clone()
}
+/// Get a string which allows debug introspection of a CoinSelection object
+pub extern "C" fn CoinSelection_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::bump_transaction::CoinSelection }).into()}
/// An abstraction over a bitcoin wallet that can perform coin selection over a set of UTXOs and can
/// sign for them. The coin selection method aims to mimic Bitcoin Core's `fundrawtransaction` RPC,
/// which most wallets should be able to satisfy. Otherwise, consider implementing [`WalletSource`],
pub select_confirmed_utxos: extern "C" fn (this_arg: *const c_void, claim_id: crate::c_types::ThirtyTwoBytes, must_spend: crate::c_types::derived::CVec_InputZ, must_pay_to: crate::c_types::derived::CVec_TxOutZ, target_feerate_sat_per_1000_weight: u32) -> crate::c_types::derived::CResult_CoinSelectionNoneZ,
/// Signs and provides the full witness for all inputs within the transaction known to the
/// trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
- pub sign_tx: extern "C" fn (this_arg: *const c_void, tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_TransactionNoneZ,
+ ///
+ /// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ /// unsigned transaction and then sign it with your wallet.
+ pub sign_psbt: extern "C" fn (this_arg: *const c_void, psbt: crate::c_types::derived::CVec_u8Z) -> crate::c_types::derived::CResult_TransactionNoneZ,
/// Frees any resources associated with this object given its this_arg pointer.
/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
}
unsafe impl Send for CoinSelectionSource {}
unsafe impl Sync for CoinSelectionSource {}
-#[no_mangle]
-pub(crate) extern "C" fn CoinSelectionSource_clone_fields(orig: &CoinSelectionSource) -> CoinSelectionSource {
+#[allow(unused)]
+pub(crate) fn CoinSelectionSource_clone_fields(orig: &CoinSelectionSource) -> CoinSelectionSource {
CoinSelectionSource {
this_arg: orig.this_arg,
select_confirmed_utxos: Clone::clone(&orig.select_confirmed_utxos),
- sign_tx: Clone::clone(&orig.sign_tx),
+ sign_psbt: Clone::clone(&orig.sign_psbt),
free: Clone::clone(&orig.free),
}
}
let mut local_ret = match ret.result_ok { true => Ok( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).take_inner()) } }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
- fn sign_tx(&self, mut tx: bitcoin::Transaction) -> Result<bitcoin::Transaction, ()> {
- let mut ret = (self.sign_tx)(self.this_arg, crate::c_types::Transaction::from_bitcoin(&tx));
+ fn sign_psbt(&self, mut psbt: bitcoin::psbt::PartiallySignedTransaction) -> Result<bitcoin::Transaction, ()> {
+ let mut ret = (self.sign_psbt)(self.this_arg, psbt.serialize().into());
let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).into_bitcoin() }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
self
}
}
+impl core::ops::DerefMut for CoinSelectionSource {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
/// Calls the free function if one is set
#[no_mangle]
pub extern "C" fn CoinSelectionSource_free(this_ptr: CoinSelectionSource) { }
pub list_confirmed_utxos: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CResult_CVec_UtxoZNoneZ,
/// Returns a script to use for change above dust resulting from a successful coin selection
/// attempt.
- pub get_change_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CResult_ScriptNoneZ,
+ pub get_change_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CResult_CVec_u8ZNoneZ,
/// Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
/// the transaction known to the wallet (i.e., any provided via
/// [`WalletSource::list_confirmed_utxos`]).
- pub sign_tx: extern "C" fn (this_arg: *const c_void, tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_TransactionNoneZ,
+ ///
+ /// If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ /// unsigned transaction and then sign it with your wallet.
+ pub sign_psbt: extern "C" fn (this_arg: *const c_void, psbt: crate::c_types::derived::CVec_u8Z) -> crate::c_types::derived::CResult_TransactionNoneZ,
/// Frees any resources associated with this object given its this_arg pointer.
/// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
}
unsafe impl Send for WalletSource {}
unsafe impl Sync for WalletSource {}
-#[no_mangle]
-pub(crate) extern "C" fn WalletSource_clone_fields(orig: &WalletSource) -> WalletSource {
+#[allow(unused)]
+pub(crate) fn WalletSource_clone_fields(orig: &WalletSource) -> WalletSource {
WalletSource {
this_arg: orig.this_arg,
list_confirmed_utxos: Clone::clone(&orig.list_confirmed_utxos),
get_change_script: Clone::clone(&orig.get_change_script),
- sign_tx: Clone::clone(&orig.sign_tx),
+ sign_psbt: Clone::clone(&orig.sign_psbt),
free: Clone::clone(&orig.free),
}
}
let mut local_ret = match ret.result_ok { true => Ok( { let mut local_ret_0 = Vec::new(); for mut item in (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).into_rust().drain(..) { local_ret_0.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; local_ret_0 }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
- fn get_change_script(&self) -> Result<bitcoin::Script, ()> {
+ fn get_change_script(&self) -> Result<bitcoin::ScriptBuf, ()> {
let mut ret = (self.get_change_script)(self.this_arg);
- let mut local_ret = match ret.result_ok { true => Ok( { ::bitcoin::blockdata::script::Script::from((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).into_rust()) }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
+ let mut local_ret = match ret.result_ok { true => Ok( { ::bitcoin::blockdata::script::ScriptBuf::from((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).into_rust()) }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
- fn sign_tx(&self, mut tx: bitcoin::Transaction) -> Result<bitcoin::Transaction, ()> {
- let mut ret = (self.sign_tx)(self.this_arg, crate::c_types::Transaction::from_bitcoin(&tx));
+ fn sign_psbt(&self, mut psbt: bitcoin::psbt::PartiallySignedTransaction) -> Result<bitcoin::Transaction, ()> {
+ let mut ret = (self.sign_psbt)(self.this_arg, psbt.serialize().into());
let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).into_bitcoin() }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
local_ret
}
self
}
}
+impl core::ops::DerefMut for WalletSource {
+ fn deref_mut(&mut self) -> &mut Self {
+ self
+ }
+}
/// Calls the free function if one is set
#[no_mangle]
pub extern "C" fn WalletSource_free(this_ptr: WalletSource) { }
impl From<nativeWallet> for crate::lightning::events::bump_transaction::CoinSelectionSource {
fn from(obj: nativeWallet) -> Self {
- let mut rust_obj = Wallet { inner: ObjOps::heap_alloc(obj), is_owned: true };
+ let rust_obj = crate::lightning::events::bump_transaction::Wallet { inner: ObjOps::heap_alloc(obj), is_owned: true };
let mut ret = Wallet_as_CoinSelectionSource(&rust_obj);
- // We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn
- rust_obj.inner = core::ptr::null_mut();
+ // We want to free rust_obj when ret gets drop()'d, not rust_obj, so forget it and set ret's free() fn
+ core::mem::forget(rust_obj);
ret.free = Some(Wallet_free_void);
ret
}
this_arg: unsafe { ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void },
free: None,
select_confirmed_utxos: Wallet_CoinSelectionSource_select_confirmed_utxos,
- sign_tx: Wallet_CoinSelectionSource_sign_tx,
+ sign_psbt: Wallet_CoinSelectionSource_sign_psbt,
}
}
local_ret
}
#[must_use]
-extern "C" fn Wallet_CoinSelectionSource_sign_tx(this_arg: *const c_void, mut tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_TransactionNoneZ {
- let mut ret = <nativeWallet as lightning::events::bump_transaction::CoinSelectionSource<>>::sign_tx(unsafe { &mut *(this_arg as *mut nativeWallet) }, tx.into_bitcoin());
+extern "C" fn Wallet_CoinSelectionSource_sign_psbt(this_arg: *const c_void, mut psbt: crate::c_types::derived::CVec_u8Z) -> crate::c_types::derived::CResult_TransactionNoneZ {
+ let mut ret = <nativeWallet as lightning::events::bump_transaction::CoinSelectionSource<>>::sign_psbt(unsafe { &mut *(this_arg as *mut nativeWallet) }, ::bitcoin::psbt::PartiallySignedTransaction::deserialize(psbt.as_slice()).expect("Invalid PSBT format"));
let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Transaction::from_bitcoin(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { () /*e*/ }).into() };
local_ret
}
projects / ldk-c-bindings / blobdiff