_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning/sign/ecdsa.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history and in the source files from which this was generated.
   3 //
   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.
   8
   9 //! Defines ECDSA-specific signer types.
  10
  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};
  19
  20 /// A trait to sign Lightning channel transactions as described in
  21 /// [BOLT 3](https://github.com/lightning/bolts/blob/master/03-transactions.md).
  22 ///
  23 /// Signing services could be implemented on a hardware wallet and should implement signing
  24 /// policies in order to be secure. Please refer to the [VLS Policy
  25 /// Controls](https://gitlab.com/lightning-signer/validating-lightning-signer/-/blob/main/docs/policy-controls.md)
  26 /// for an example of such policies.
  27 #[repr(C)]
  28 pub struct EcdsaChannelSigner {
  29         /// An opaque pointer which is passed to your function implementations as an argument.
  30         /// This has no meaning in the LDK, and can be NULL or any other value.
  31         pub this_arg: *mut c_void,
  32         /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
  33         ///
  34         /// Note that if signing fails or is rejected, the channel will be force-closed.
  35         ///
  36         /// Policy checks should be implemented in this function, including checking the amount
  37         /// sent to us and checking the HTLCs.
  38         ///
  39         /// The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
  40         /// are provided. A validating signer should ensure that an outbound HTLC output is removed
  41         /// only when the matching preimage is provided and after the corresponding inbound HTLC has
  42         /// been removed for forwarded payments.
  43         ///
  44         /// Note that all the relevant preimages will be provided, but there may also be additional
  45         /// irrelevant or duplicate preimages.
  46         pub sign_counterparty_commitment: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::CommitmentTransaction, inbound_htlc_preimages: crate::c_types::derived::CVec_ThirtyTwoBytesZ, outbound_htlc_preimages: crate::c_types::derived::CVec_ThirtyTwoBytesZ) -> crate::c_types::derived::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ,
  47         /// Creates a signature for a holder's commitment transaction.
  48         ///
  49         /// This will be called
  50         /// - with a non-revoked `commitment_tx`.
  51         /// - with the latest `commitment_tx` when we initiate a force-close.
  52         ///
  53         /// This may be called multiple times for the same transaction.
  54         ///
  55         /// An external signer implementation should check that the commitment has not been revoked.
  56         pub sign_holder_commitment: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::HolderCommitmentTransaction) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
  57         /// Create a signature for the given input in a transaction spending an HTLC transaction output
  58         /// or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
  59         ///
  60         /// A justice transaction may claim multiple outputs at the same time if timelocks are
  61         /// similar, but only a signature for the input at index `input` should be signed for here.
  62         /// It may be called multiple times for same output(s) if a fee-bump is needed with regards
  63         /// to an upcoming timelock expiration.
  64         ///
  65         /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
  66         ///
  67         /// `per_commitment_key` is revocation secret which was provided by our counterparty when they
  68         /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
  69         /// not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
  70         /// so).
  71         pub sign_justice_revoked_output: extern "C" fn (this_arg: *const c_void, justice_tx: crate::c_types::Transaction, input: usize, amount: u64, per_commitment_key: *const [u8; 32]) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
  72         /// Create a signature for the given input in a transaction spending a commitment transaction
  73         /// HTLC output when our counterparty broadcasts an old state.
  74         ///
  75         /// A justice transaction may claim multiple outputs at the same time if timelocks are
  76         /// similar, but only a signature for the input at index `input` should be signed for here.
  77         /// It may be called multiple times for same output(s) if a fee-bump is needed with regards
  78         /// to an upcoming timelock expiration.
  79         ///
  80         /// `amount` is the value of the output spent by this input, committed to in the BIP 143
  81         /// signature.
  82         ///
  83         /// `per_commitment_key` is revocation secret which was provided by our counterparty when they
  84         /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
  85         /// not allow the spending of any funds by itself (you need our holder revocation_secret to do
  86         /// so).
  87         ///
  88         /// `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
  89         /// (which is committed to in the BIP 143 signatures).
  90         pub sign_justice_revoked_htlc: extern "C" fn (this_arg: *const c_void, justice_tx: crate::c_types::Transaction, input: usize, amount: u64, per_commitment_key: *const [u8; 32], htlc: &crate::lightning::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
  91         /// Computes the signature for a commitment transaction's HTLC output used as an input within
  92         /// `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
  93         /// must be be computed using [`EcdsaSighashType::All`].
  94         ///
  95         /// Note that this may be called for HTLCs in the penultimate commitment transaction if a
  96         /// [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
  97         /// broadcasts it before receiving the update for the latest commitment transaction.
  98         ///
  99         /// [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
 100         /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
 101         pub sign_holder_htlc_transaction: extern "C" fn (this_arg: *const c_void, htlc_tx: crate::c_types::Transaction, input: usize, htlc_descriptor: &crate::lightning::sign::HTLCDescriptor) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
 102         /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
 103         /// transaction, either offered or received.
 104         ///
 105         /// Such a transaction may claim multiples offered outputs at same time if we know the
 106         /// preimage for each when we create it, but only the input at index `input` should be
 107         /// signed for here. It may be called multiple times for same output(s) if a fee-bump is
 108         /// needed with regards to an upcoming timelock expiration.
 109         ///
 110         /// `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
 111         /// outputs.
 112         ///
 113         /// `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
 114         ///
 115         /// `per_commitment_point` is the dynamic point corresponding to the channel state
 116         /// detected onchain. It has been generated by our counterparty and is used to derive
 117         /// channel state keys, which are then included in the witness script and committed to in the
 118         /// BIP 143 signature.
 119         pub sign_counterparty_htlc_transaction: extern "C" fn (this_arg: *const c_void, htlc_tx: crate::c_types::Transaction, input: usize, amount: u64, per_commitment_point: crate::c_types::PublicKey, htlc: &crate::lightning::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
 120         /// Create a signature for a (proposed) closing transaction.
 121         ///
 122         /// Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
 123         /// chosen to forgo their output as dust.
 124         pub sign_closing_transaction: extern "C" fn (this_arg: *const c_void, closing_tx: &crate::lightning::ln::chan_utils::ClosingTransaction) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
 125         /// Computes the signature for a commitment transaction's anchor output used as an
 126         /// input within `anchor_tx`, which spends the commitment transaction, at index `input`.
 127         pub sign_holder_anchor_input: extern "C" fn (this_arg: *const c_void, anchor_tx: crate::c_types::Transaction, input: usize) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
 128         /// Signs a channel announcement message with our funding key proving it comes from one of the
 129         /// channel participants.
 130         ///
 131         /// Channel announcements also require a signature from each node's network key. Our node
 132         /// signature is computed through [`NodeSigner::sign_gossip_message`].
 133         ///
 134         /// Note that if this fails or is rejected, the channel will not be publicly announced and
 135         /// our counterparty may (though likely will not) close the channel on us for violating the
 136         /// protocol.
 137         ///
 138         /// [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
 139         pub sign_channel_announcement_with_funding_key: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_ECDSASignatureNoneZ,
 140         /// Implementation of ChannelSigner for this object.
 141         pub ChannelSigner: crate::lightning::sign::ChannelSigner,
 142         /// Frees any resources associated with this object given its this_arg pointer.
 143         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 144         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 145 }
 146 unsafe impl Send for EcdsaChannelSigner {}
 147 unsafe impl Sync for EcdsaChannelSigner {}
 148 #[allow(unused)]
 149 pub(crate) fn EcdsaChannelSigner_clone_fields(orig: &EcdsaChannelSigner) -> EcdsaChannelSigner {
 150         EcdsaChannelSigner {
 151                 this_arg: orig.this_arg,
 152                 sign_counterparty_commitment: Clone::clone(&orig.sign_counterparty_commitment),
 153                 sign_holder_commitment: Clone::clone(&orig.sign_holder_commitment),
 154                 sign_justice_revoked_output: Clone::clone(&orig.sign_justice_revoked_output),
 155                 sign_justice_revoked_htlc: Clone::clone(&orig.sign_justice_revoked_htlc),
 156                 sign_holder_htlc_transaction: Clone::clone(&orig.sign_holder_htlc_transaction),
 157                 sign_counterparty_htlc_transaction: Clone::clone(&orig.sign_counterparty_htlc_transaction),
 158                 sign_closing_transaction: Clone::clone(&orig.sign_closing_transaction),
 159                 sign_holder_anchor_input: Clone::clone(&orig.sign_holder_anchor_input),
 160                 sign_channel_announcement_with_funding_key: Clone::clone(&orig.sign_channel_announcement_with_funding_key),
 161                 ChannelSigner: crate::lightning::sign::ChannelSigner_clone_fields(&orig.ChannelSigner),
 162                 free: Clone::clone(&orig.free),
 163         }
 164 }
 165 impl lightning::sign::ChannelSigner for EcdsaChannelSigner {
 166         fn get_per_commitment_point(&self, mut idx: u64, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::PublicKey {
 167                 let mut ret = (self.ChannelSigner.get_per_commitment_point)(self.ChannelSigner.this_arg, idx);
 168                 ret.into_rust()
 169         }
 170         fn release_commitment_secret(&self, mut idx: u64) -> [u8; 32] {
 171                 let mut ret = (self.ChannelSigner.release_commitment_secret)(self.ChannelSigner.this_arg, idx);
 172                 ret.data
 173         }
 174         fn validate_holder_commitment(&self, mut holder_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut outbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>) -> Result<(), ()> {
 175                 let mut local_outbound_htlc_preimages = Vec::new(); for mut item in outbound_htlc_preimages.drain(..) { local_outbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 176                 let mut ret = (self.ChannelSigner.validate_holder_commitment)(self.ChannelSigner.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((holder_tx as *const lightning::ln::chan_utils::HolderCommitmentTransaction<>) as *mut _) }, is_owned: false }, local_outbound_htlc_preimages.into());
 177                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 178                 local_ret
 179         }
 180         fn validate_counterparty_revocation(&self, mut idx: u64, mut secret: &bitcoin::secp256k1::SecretKey) -> Result<(), ()> {
 181                 let mut ret = (self.ChannelSigner.validate_counterparty_revocation)(self.ChannelSigner.this_arg, idx, secret.as_ref());
 182                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 183                 local_ret
 184         }
 185         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 186                 if let Some(f) = self.ChannelSigner.set_pubkeys {
 187                         (f)(&self.ChannelSigner);
 188                 }
 189                 unsafe { &*self.ChannelSigner.pubkeys.get() }.get_native_ref()
 190         }
 191         fn channel_keys_id(&self) -> [u8; 32] {
 192                 let mut ret = (self.ChannelSigner.channel_keys_id)(self.ChannelSigner.this_arg);
 193                 ret.data
 194         }
 195         fn provide_channel_parameters(&mut self, mut channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 196                 (self.ChannelSigner.provide_channel_parameters)(self.ChannelSigner.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((channel_parameters as *const lightning::ln::chan_utils::ChannelTransactionParameters<>) as *mut _) }, is_owned: false })
 197         }
 198 }
 199
 200 use lightning::sign::ecdsa::EcdsaChannelSigner as rustEcdsaChannelSigner;
 201 impl rustEcdsaChannelSigner for EcdsaChannelSigner {
 202         fn sign_counterparty_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, mut inbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>, mut outbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::ecdsa::Signature, Vec<bitcoin::secp256k1::ecdsa::Signature>), ()> {
 203                 let mut local_inbound_htlc_preimages = Vec::new(); for mut item in inbound_htlc_preimages.drain(..) { local_inbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 204                 let mut local_outbound_htlc_preimages = Vec::new(); for mut item in outbound_htlc_preimages.drain(..) { local_outbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 205                 let mut ret = (self.sign_counterparty_commitment)(self.this_arg, &crate::lightning::ln::chan_utils::CommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((commitment_tx as *const lightning::ln::chan_utils::CommitmentTransaction<>) as *mut _) }, is_owned: false }, local_inbound_htlc_preimages.into(), local_outbound_htlc_preimages.into());
 206                 let mut local_ret = match ret.result_ok { true => Ok( { let (mut orig_ret_0_0, mut orig_ret_0_1) = (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).to_rust(); let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.into_rust().drain(..) { local_orig_ret_0_1.push( { item.into_rust() }); }; let mut local_ret_0 = (orig_ret_0_0.into_rust(), local_orig_ret_0_1); local_ret_0 }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 207                 local_ret
 208         }
 209         fn sign_holder_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 210                 let mut ret = (self.sign_holder_commitment)(self.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((commitment_tx as *const lightning::ln::chan_utils::HolderCommitmentTransaction<>) as *mut _) }, is_owned: false });
 211                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 212                 local_ret
 213         }
 214         fn sign_justice_revoked_output(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::SecretKey, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 215                 let mut ret = (self.sign_justice_revoked_output)(self.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref());
 216                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 217                 local_ret
 218         }
 219         fn sign_justice_revoked_htlc(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::SecretKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 220                 let mut ret = (self.sign_justice_revoked_htlc)(self.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref(), &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc as *const lightning::ln::chan_utils::HTLCOutputInCommitment<>) as *mut _) }, is_owned: false });
 221                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 222                 local_ret
 223         }
 224         fn sign_holder_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut htlc_descriptor: &lightning::sign::HTLCDescriptor, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 225                 let mut ret = (self.sign_holder_htlc_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(htlc_tx), input, &crate::lightning::sign::HTLCDescriptor { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc_descriptor as *const lightning::sign::HTLCDescriptor<>) as *mut _) }, is_owned: false });
 226                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 227                 local_ret
 228         }
 229         fn sign_counterparty_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_point: &bitcoin::secp256k1::PublicKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 230                 let mut ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(htlc_tx), input, amount, crate::c_types::PublicKey::from_rust(&per_commitment_point), &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc as *const lightning::ln::chan_utils::HTLCOutputInCommitment<>) as *mut _) }, is_owned: false });
 231                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 232                 local_ret
 233         }
 234         fn sign_closing_transaction(&self, mut closing_tx: &lightning::ln::chan_utils::ClosingTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 235                 let mut ret = (self.sign_closing_transaction)(self.this_arg, &crate::lightning::ln::chan_utils::ClosingTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((closing_tx as *const lightning::ln::chan_utils::ClosingTransaction<>) as *mut _) }, is_owned: false });
 236                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 237                 local_ret
 238         }
 239         fn sign_holder_anchor_input(&self, mut anchor_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 240                 let mut ret = (self.sign_holder_anchor_input)(self.this_arg, crate::c_types::Transaction::from_bitcoin(anchor_tx), input);
 241                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 242                 local_ret
 243         }
 244         fn sign_channel_announcement_with_funding_key(&self, mut msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 245                 let mut ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, &crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UnsignedChannelAnnouncement<>) as *mut _) }, is_owned: false });
 246                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 247                 local_ret
 248         }
 249 }
 250
 251 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 252 // directly as a Deref trait in higher-level structs:
 253 impl core::ops::Deref for EcdsaChannelSigner {
 254         type Target = Self;
 255         fn deref(&self) -> &Self {
 256                 self
 257         }
 258 }
 259 impl core::ops::DerefMut for EcdsaChannelSigner {
 260         fn deref_mut(&mut self) -> &mut Self {
 261                 self
 262         }
 263 }
 264 /// Calls the free function if one is set
 265 #[no_mangle]
 266 pub extern "C" fn EcdsaChannelSigner_free(this_ptr: EcdsaChannelSigner) { }
 267 impl Drop for EcdsaChannelSigner {
 268         fn drop(&mut self) {
 269                 if let Some(f) = self.free {
 270                         f(self.this_arg);
 271                 }
 272         }
 273 }
 274 /// A writeable signer.
 275 ///
 276 /// There will always be two instances of a signer per channel, one occupied by the
 277 /// [`ChannelManager`] and another by the channel's [`ChannelMonitor`].
 278 ///
 279 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
 280 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
 281 #[repr(C)]
 282 pub struct WriteableEcdsaChannelSigner {
 283         /// An opaque pointer which is passed to your function implementations as an argument.
 284         /// This has no meaning in the LDK, and can be NULL or any other value.
 285         pub this_arg: *mut c_void,
 286         /// Implementation of EcdsaChannelSigner for this object.
 287         pub EcdsaChannelSigner: crate::lightning::sign::ecdsa::EcdsaChannelSigner,
 288         /// Serialize the object into a byte array
 289         pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 290         /// Called, if set, after this WriteableEcdsaChannelSigner has been cloned into a duplicate object.
 291         /// The new WriteableEcdsaChannelSigner is provided, and should be mutated as needed to perform a
 292         /// deep copy of the object pointed to by this_arg or avoid any double-freeing.
 293         pub cloned: Option<extern "C" fn (new_WriteableEcdsaChannelSigner: &mut WriteableEcdsaChannelSigner)>,
 294         /// Frees any resources associated with this object given its this_arg pointer.
 295         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 296         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 297 }
 298 unsafe impl Send for WriteableEcdsaChannelSigner {}
 299 unsafe impl Sync for WriteableEcdsaChannelSigner {}
 300 #[allow(unused)]
 301 pub(crate) fn WriteableEcdsaChannelSigner_clone_fields(orig: &WriteableEcdsaChannelSigner) -> WriteableEcdsaChannelSigner {
 302         WriteableEcdsaChannelSigner {
 303                 this_arg: orig.this_arg,
 304                 EcdsaChannelSigner: crate::lightning::sign::ecdsa::EcdsaChannelSigner_clone_fields(&orig.EcdsaChannelSigner),
 305                 write: Clone::clone(&orig.write),
 306                 cloned: Clone::clone(&orig.cloned),
 307                 free: Clone::clone(&orig.free),
 308         }
 309 }
 310 impl lightning::sign::ecdsa::EcdsaChannelSigner for WriteableEcdsaChannelSigner {
 311         fn sign_counterparty_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, mut inbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>, mut outbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::ecdsa::Signature, Vec<bitcoin::secp256k1::ecdsa::Signature>), ()> {
 312                 let mut local_inbound_htlc_preimages = Vec::new(); for mut item in inbound_htlc_preimages.drain(..) { local_inbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 313                 let mut local_outbound_htlc_preimages = Vec::new(); for mut item in outbound_htlc_preimages.drain(..) { local_outbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 314                 let mut ret = (self.EcdsaChannelSigner.sign_counterparty_commitment)(self.EcdsaChannelSigner.this_arg, &crate::lightning::ln::chan_utils::CommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((commitment_tx as *const lightning::ln::chan_utils::CommitmentTransaction<>) as *mut _) }, is_owned: false }, local_inbound_htlc_preimages.into(), local_outbound_htlc_preimages.into());
 315                 let mut local_ret = match ret.result_ok { true => Ok( { let (mut orig_ret_0_0, mut orig_ret_0_1) = (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }).to_rust(); let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.into_rust().drain(..) { local_orig_ret_0_1.push( { item.into_rust() }); }; let mut local_ret_0 = (orig_ret_0_0.into_rust(), local_orig_ret_0_1); local_ret_0 }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 316                 local_ret
 317         }
 318         fn sign_holder_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 319                 let mut ret = (self.EcdsaChannelSigner.sign_holder_commitment)(self.EcdsaChannelSigner.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((commitment_tx as *const lightning::ln::chan_utils::HolderCommitmentTransaction<>) as *mut _) }, is_owned: false });
 320                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 321                 local_ret
 322         }
 323         fn sign_justice_revoked_output(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::SecretKey, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 324                 let mut ret = (self.EcdsaChannelSigner.sign_justice_revoked_output)(self.EcdsaChannelSigner.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref());
 325                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 326                 local_ret
 327         }
 328         fn sign_justice_revoked_htlc(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::SecretKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 329                 let mut ret = (self.EcdsaChannelSigner.sign_justice_revoked_htlc)(self.EcdsaChannelSigner.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref(), &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc as *const lightning::ln::chan_utils::HTLCOutputInCommitment<>) as *mut _) }, is_owned: false });
 330                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 331                 local_ret
 332         }
 333         fn sign_holder_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut htlc_descriptor: &lightning::sign::HTLCDescriptor, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 334                 let mut ret = (self.EcdsaChannelSigner.sign_holder_htlc_transaction)(self.EcdsaChannelSigner.this_arg, crate::c_types::Transaction::from_bitcoin(htlc_tx), input, &crate::lightning::sign::HTLCDescriptor { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc_descriptor as *const lightning::sign::HTLCDescriptor<>) as *mut _) }, is_owned: false });
 335                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 336                 local_ret
 337         }
 338         fn sign_counterparty_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_point: &bitcoin::secp256k1::PublicKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 339                 let mut ret = (self.EcdsaChannelSigner.sign_counterparty_htlc_transaction)(self.EcdsaChannelSigner.this_arg, crate::c_types::Transaction::from_bitcoin(htlc_tx), input, amount, crate::c_types::PublicKey::from_rust(&per_commitment_point), &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ObjOps::nonnull_ptr_to_inner((htlc as *const lightning::ln::chan_utils::HTLCOutputInCommitment<>) as *mut _) }, is_owned: false });
 340                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 341                 local_ret
 342         }
 343         fn sign_closing_transaction(&self, mut closing_tx: &lightning::ln::chan_utils::ClosingTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 344                 let mut ret = (self.EcdsaChannelSigner.sign_closing_transaction)(self.EcdsaChannelSigner.this_arg, &crate::lightning::ln::chan_utils::ClosingTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((closing_tx as *const lightning::ln::chan_utils::ClosingTransaction<>) as *mut _) }, is_owned: false });
 345                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 346                 local_ret
 347         }
 348         fn sign_holder_anchor_input(&self, mut anchor_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 349                 let mut ret = (self.EcdsaChannelSigner.sign_holder_anchor_input)(self.EcdsaChannelSigner.this_arg, crate::c_types::Transaction::from_bitcoin(anchor_tx), input);
 350                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 351                 local_ret
 352         }
 353         fn sign_channel_announcement_with_funding_key(&self, mut msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::ecdsa::Signature, ()> {
 354                 let mut ret = (self.EcdsaChannelSigner.sign_channel_announcement_with_funding_key)(self.EcdsaChannelSigner.this_arg, &crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UnsignedChannelAnnouncement<>) as *mut _) }, is_owned: false });
 355                 let mut local_ret = match ret.result_ok { true => Ok( { (*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)) })*/ })};
 356                 local_ret
 357         }
 358 }
 359 impl lightning::sign::ChannelSigner for WriteableEcdsaChannelSigner {
 360         fn get_per_commitment_point(&self, mut idx: u64, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::PublicKey {
 361                 let mut ret = (self.EcdsaChannelSigner.ChannelSigner.get_per_commitment_point)(self.EcdsaChannelSigner.ChannelSigner.this_arg, idx);
 362                 ret.into_rust()
 363         }
 364         fn release_commitment_secret(&self, mut idx: u64) -> [u8; 32] {
 365                 let mut ret = (self.EcdsaChannelSigner.ChannelSigner.release_commitment_secret)(self.EcdsaChannelSigner.ChannelSigner.this_arg, idx);
 366                 ret.data
 367         }
 368         fn validate_holder_commitment(&self, mut holder_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut outbound_htlc_preimages: Vec<lightning::ln::PaymentPreimage>) -> Result<(), ()> {
 369                 let mut local_outbound_htlc_preimages = Vec::new(); for mut item in outbound_htlc_preimages.drain(..) { local_outbound_htlc_preimages.push( { crate::c_types::ThirtyTwoBytes { data: item.0 } }); };
 370                 let mut ret = (self.EcdsaChannelSigner.ChannelSigner.validate_holder_commitment)(self.EcdsaChannelSigner.ChannelSigner.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { ObjOps::nonnull_ptr_to_inner((holder_tx as *const lightning::ln::chan_utils::HolderCommitmentTransaction<>) as *mut _) }, is_owned: false }, local_outbound_htlc_preimages.into());
 371                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 372                 local_ret
 373         }
 374         fn validate_counterparty_revocation(&self, mut idx: u64, mut secret: &bitcoin::secp256k1::SecretKey) -> Result<(), ()> {
 375                 let mut ret = (self.EcdsaChannelSigner.ChannelSigner.validate_counterparty_revocation)(self.EcdsaChannelSigner.ChannelSigner.this_arg, idx, secret.as_ref());
 376                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) })*/ })};
 377                 local_ret
 378         }
 379         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 380                 if let Some(f) = self.EcdsaChannelSigner.ChannelSigner.set_pubkeys {
 381                         (f)(&self.EcdsaChannelSigner.ChannelSigner);
 382                 }
 383                 unsafe { &*self.EcdsaChannelSigner.ChannelSigner.pubkeys.get() }.get_native_ref()
 384         }
 385         fn channel_keys_id(&self) -> [u8; 32] {
 386                 let mut ret = (self.EcdsaChannelSigner.ChannelSigner.channel_keys_id)(self.EcdsaChannelSigner.ChannelSigner.this_arg);
 387                 ret.data
 388         }
 389         fn provide_channel_parameters(&mut self, mut channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 390                 (self.EcdsaChannelSigner.ChannelSigner.provide_channel_parameters)(self.EcdsaChannelSigner.ChannelSigner.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((channel_parameters as *const lightning::ln::chan_utils::ChannelTransactionParameters<>) as *mut _) }, is_owned: false })
 391         }
 392 }
 393 impl lightning::util::ser::Writeable for WriteableEcdsaChannelSigner {
 394         fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), crate::c_types::io::Error> {
 395                 let vec = (self.write)(self.this_arg);
 396                 w.write_all(vec.as_slice())
 397         }
 398 }
 399 #[no_mangle]
 400 /// Creates a copy of a WriteableEcdsaChannelSigner
 401 pub extern "C" fn WriteableEcdsaChannelSigner_clone(orig: &WriteableEcdsaChannelSigner) -> WriteableEcdsaChannelSigner {
 402         let mut res = WriteableEcdsaChannelSigner_clone_fields(orig);
 403         if let Some(f) = orig.cloned { (f)(&mut res) };
 404         res
 405 }
 406 impl Clone for WriteableEcdsaChannelSigner {
 407         fn clone(&self) -> Self {
 408                 WriteableEcdsaChannelSigner_clone(self)
 409         }
 410 }
 411
 412 use lightning::sign::ecdsa::WriteableEcdsaChannelSigner as rustWriteableEcdsaChannelSigner;
 413 impl rustWriteableEcdsaChannelSigner for WriteableEcdsaChannelSigner {
 414 }
 415
 416 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 417 // directly as a Deref trait in higher-level structs:
 418 impl core::ops::Deref for WriteableEcdsaChannelSigner {
 419         type Target = Self;
 420         fn deref(&self) -> &Self {
 421                 self
 422         }
 423 }
 424 impl core::ops::DerefMut for WriteableEcdsaChannelSigner {
 425         fn deref_mut(&mut self) -> &mut Self {
 426                 self
 427         }
 428 }
 429 /// Calls the free function if one is set
 430 #[no_mangle]
 431 pub extern "C" fn WriteableEcdsaChannelSigner_free(this_ptr: WriteableEcdsaChannelSigner) { }
 432 impl Drop for WriteableEcdsaChannelSigner {
 433         fn drop(&mut self) {
 434                 if let Some(f) = self.free {
 435                         f(self.this_arg);
 436                 }
 437         }
 438 }