X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning%2Fevents%2Fbump_transaction.rs;h=dd8117067ad11af86b792491d10304735d28d320;hb=0ac4dbdb8352c898100b34f0ef8ed9cebfea7786;hp=0ff12a5b35d9b8d633daf306e7691e80a1d2e23f;hpb=48e3445a78b643c837e7d489d90588eb877d0319;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/lightning/events/bump_transaction.rs b/lightning-c-bindings/src/lightning/events/bump_transaction.rs index 0ff12a5..dd81170 100644 --- a/lightning-c-bindings/src/lightning/events/bump_transaction.rs +++ b/lightning-c-bindings/src/lightning/events/bump_transaction.rs @@ -11,6 +11,7 @@ //! [`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; @@ -19,134 +20,6 @@ use crate::c_types::*; 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; @@ -199,13 +72,13 @@ impl AnchorDescriptor { } /// 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 @@ -224,7 +97,7 @@ pub extern "C" fn AnchorDescriptor_set_outpoint(this_ptr: &mut AnchorDescriptor, /// 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), @@ -242,13 +115,16 @@ impl Clone for AnchorDescriptor { #[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. @@ -281,14 +157,14 @@ pub extern "C" fn AnchorDescriptor_unsigned_tx_input(this_arg: &crate::lightning #[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) } @@ -296,225 +172,7 @@ pub extern "C" fn AnchorDescriptor_tx_input_witness(this_arg: &crate::lightning: /// 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 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 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 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) } @@ -560,8 +218,8 @@ pub enum BumpTransactionEvent { /// 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. @@ -614,9 +272,8 @@ pub enum BumpTransactionEvent { /// 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. @@ -668,7 +325,7 @@ impl BumpTransactionEvent { 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), } }, } @@ -693,13 +350,14 @@ impl BumpTransactionEvent { 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); @@ -722,13 +380,13 @@ impl BumpTransactionEvent { 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(), } }, } @@ -748,12 +406,12 @@ impl BumpTransactionEvent { } }, 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(), } }, } @@ -767,6 +425,16 @@ pub extern "C" fn BumpTransactionEvent_free(this_ptr: BumpTransactionEvent) { } 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 { @@ -789,6 +457,9 @@ pub extern "C" fn BumpTransactionEvent_htlcresolution(claim_id: crate::c_types:: 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] @@ -907,13 +578,16 @@ impl Clone for Input { #[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 { @@ -1044,13 +718,16 @@ impl Clone for Utxo { #[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 { @@ -1074,7 +751,7 @@ pub extern "C" fn Utxo_eq(a: &Utxo, b: &Utxo) -> bool { #[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 } } @@ -1187,13 +864,16 @@ impl Clone for CoinSelection { #[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`], @@ -1232,19 +912,22 @@ pub struct CoinSelectionSource { 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, } 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), } } @@ -1258,8 +941,8 @@ impl rustCoinSelectionSource for CoinSelectionSource { 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 { - 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 { + 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 } @@ -1273,6 +956,11 @@ impl core::ops::Deref for CoinSelectionSource { 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) { } @@ -1294,24 +982,27 @@ pub struct WalletSource { 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, } 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), } } @@ -1323,13 +1014,13 @@ impl rustWalletSource for WalletSource { 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 { + fn get_change_script(&self) -> Result { 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 { - 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 { + 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 } @@ -1343,6 +1034,11 @@ impl core::ops::Deref for WalletSource { 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) { } @@ -1417,10 +1113,10 @@ pub extern "C" fn Wallet_new(mut source: crate::lightning::events::bump_transact impl From 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 } @@ -1433,7 +1129,7 @@ pub extern "C" fn Wallet_as_CoinSelectionSource(this_arg: &Wallet) -> crate::lig 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, } } @@ -1446,8 +1142,8 @@ extern "C" fn Wallet_CoinSelectionSource_select_confirmed_utxos(this_arg: *const 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 = >::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 = >::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 }