_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning/chain/keysinterface.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 //! keysinterface provides keys into rust-lightning and defines some useful enums which describe
  10 //! spendable on-chain outputs which the user owns and is responsible for using just as any other
  11 //! on-chain output which is theirs.
  12
  13 use std::str::FromStr;
  14 use std::ffi::c_void;
  15 use bitcoin::hashes::Hash;
  16 use crate::c_types::*;
  17
  18
  19 use lightning::chain::keysinterface::DelayedPaymentOutputDescriptor as nativeDelayedPaymentOutputDescriptorImport;
  20 type nativeDelayedPaymentOutputDescriptor = nativeDelayedPaymentOutputDescriptorImport;
  21
  22 /// Information about a spendable output to a P2WSH script. See
  23 /// SpendableOutputDescriptor::DelayedPaymentOutput for more details on how to spend this.
  24 #[must_use]
  25 #[repr(C)]
  26 pub struct DelayedPaymentOutputDescriptor {
  27         /// A pointer to the opaque Rust object.
  28
  29         /// Nearly everywhere, inner must be non-null, however in places where
  30         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
  31         pub inner: *mut nativeDelayedPaymentOutputDescriptor,
  32         /// Indicates that this is the only struct which contains the same pointer.
  33
  34         /// Rust functions which take ownership of an object provided via an argument require
  35         /// this to be true and invalidate the object pointed to by inner.
  36         pub is_owned: bool,
  37 }
  38
  39 impl Drop for DelayedPaymentOutputDescriptor {
  40         fn drop(&mut self) {
  41                 if self.is_owned && !<*mut nativeDelayedPaymentOutputDescriptor>::is_null(self.inner) {
  42                         let _ = unsafe { Box::from_raw(self.inner) };
  43                 }
  44         }
  45 }
  46 /// Frees any resources used by the DelayedPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
  47 #[no_mangle]
  48 pub extern "C" fn DelayedPaymentOutputDescriptor_free(this_obj: DelayedPaymentOutputDescriptor) { }
  49 #[allow(unused)]
  50 /// Used only if an object of this type is returned as a trait impl by a method
  51 extern "C" fn DelayedPaymentOutputDescriptor_free_void(this_ptr: *mut c_void) {
  52         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDelayedPaymentOutputDescriptor); }
  53 }
  54 #[allow(unused)]
  55 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
  56 impl DelayedPaymentOutputDescriptor {
  57         pub(crate) fn take_inner(mut self) -> *mut nativeDelayedPaymentOutputDescriptor {
  58                 assert!(self.is_owned);
  59                 let ret = self.inner;
  60                 self.inner = std::ptr::null_mut();
  61                 ret
  62         }
  63 }
  64 /// The outpoint which is spendable
  65 #[no_mangle]
  66 pub extern "C" fn DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: &DelayedPaymentOutputDescriptor) -> crate::lightning::chain::transaction::OutPoint {
  67         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.outpoint;
  68         crate::lightning::chain::transaction::OutPoint { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
  69 }
  70 /// The outpoint which is spendable
  71 #[no_mangle]
  72 pub extern "C" fn DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: crate::lightning::chain::transaction::OutPoint) {
  73         unsafe { &mut *this_ptr.inner }.outpoint = *unsafe { Box::from_raw(val.take_inner()) };
  74 }
  75 /// Per commitment point to derive delayed_payment_key by key holder
  76 #[no_mangle]
  77 pub extern "C" fn DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: &DelayedPaymentOutputDescriptor) -> crate::c_types::PublicKey {
  78         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.per_commitment_point;
  79         crate::c_types::PublicKey::from_rust(&inner_val)
  80 }
  81 /// Per commitment point to derive delayed_payment_key by key holder
  82 #[no_mangle]
  83 pub extern "C" fn DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: crate::c_types::PublicKey) {
  84         unsafe { &mut *this_ptr.inner }.per_commitment_point = val.into_rust();
  85 }
  86 /// The nSequence value which must be set in the spending input to satisfy the OP_CSV in
  87 /// the witness_script.
  88 #[no_mangle]
  89 pub extern "C" fn DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: &DelayedPaymentOutputDescriptor) -> u16 {
  90         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.to_self_delay;
  91         *inner_val
  92 }
  93 /// The nSequence value which must be set in the spending input to satisfy the OP_CSV in
  94 /// the witness_script.
  95 #[no_mangle]
  96 pub extern "C" fn DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: u16) {
  97         unsafe { &mut *this_ptr.inner }.to_self_delay = val;
  98 }
  99 /// The output which is referenced by the given outpoint
 100 #[no_mangle]
 101 pub extern "C" fn DelayedPaymentOutputDescriptor_set_output(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: crate::c_types::TxOut) {
 102         unsafe { &mut *this_ptr.inner }.output = val.into_rust();
 103 }
 104 /// The revocation point specific to the commitment transaction which was broadcast. Used to
 105 /// derive the witnessScript for this output.
 106 #[no_mangle]
 107 pub extern "C" fn DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: &DelayedPaymentOutputDescriptor) -> crate::c_types::PublicKey {
 108         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_pubkey;
 109         crate::c_types::PublicKey::from_rust(&inner_val)
 110 }
 111 /// The revocation point specific to the commitment transaction which was broadcast. Used to
 112 /// derive the witnessScript for this output.
 113 #[no_mangle]
 114 pub extern "C" fn DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: crate::c_types::PublicKey) {
 115         unsafe { &mut *this_ptr.inner }.revocation_pubkey = val.into_rust();
 116 }
 117 /// Arbitrary identification information returned by a call to
 118 /// `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
 119 /// the channel to spend the output.
 120 #[no_mangle]
 121 pub extern "C" fn DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: &DelayedPaymentOutputDescriptor) -> *const [u8; 32] {
 122         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_keys_id;
 123         inner_val
 124 }
 125 /// Arbitrary identification information returned by a call to
 126 /// `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
 127 /// the channel to spend the output.
 128 #[no_mangle]
 129 pub extern "C" fn DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: crate::c_types::ThirtyTwoBytes) {
 130         unsafe { &mut *this_ptr.inner }.channel_keys_id = val.data;
 131 }
 132 /// The value of the channel which this output originated from, possibly indirectly.
 133 #[no_mangle]
 134 pub extern "C" fn DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: &DelayedPaymentOutputDescriptor) -> u64 {
 135         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_value_satoshis;
 136         *inner_val
 137 }
 138 /// The value of the channel which this output originated from, possibly indirectly.
 139 #[no_mangle]
 140 pub extern "C" fn DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: &mut DelayedPaymentOutputDescriptor, mut val: u64) {
 141         unsafe { &mut *this_ptr.inner }.channel_value_satoshis = val;
 142 }
 143 /// Constructs a new DelayedPaymentOutputDescriptor given each field
 144 #[must_use]
 145 #[no_mangle]
 146 pub extern "C" fn DelayedPaymentOutputDescriptor_new(mut outpoint_arg: crate::lightning::chain::transaction::OutPoint, mut per_commitment_point_arg: crate::c_types::PublicKey, mut to_self_delay_arg: u16, mut output_arg: crate::c_types::TxOut, mut revocation_pubkey_arg: crate::c_types::PublicKey, mut channel_keys_id_arg: crate::c_types::ThirtyTwoBytes, mut channel_value_satoshis_arg: u64) -> DelayedPaymentOutputDescriptor {
 147         DelayedPaymentOutputDescriptor { inner: Box::into_raw(Box::new(nativeDelayedPaymentOutputDescriptor {
 148                 outpoint: *unsafe { Box::from_raw(outpoint_arg.take_inner()) },
 149                 per_commitment_point: per_commitment_point_arg.into_rust(),
 150                 to_self_delay: to_self_delay_arg,
 151                 output: output_arg.into_rust(),
 152                 revocation_pubkey: revocation_pubkey_arg.into_rust(),
 153                 channel_keys_id: channel_keys_id_arg.data,
 154                 channel_value_satoshis: channel_value_satoshis_arg,
 155         })), is_owned: true }
 156 }
 157 impl Clone for DelayedPaymentOutputDescriptor {
 158         fn clone(&self) -> Self {
 159                 Self {
 160                         inner: if <*mut nativeDelayedPaymentOutputDescriptor>::is_null(self.inner) { std::ptr::null_mut() } else {
 161                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
 162                         is_owned: true,
 163                 }
 164         }
 165 }
 166 #[allow(unused)]
 167 /// Used only if an object of this type is returned as a trait impl by a method
 168 pub(crate) extern "C" fn DelayedPaymentOutputDescriptor_clone_void(this_ptr: *const c_void) -> *mut c_void {
 169         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDelayedPaymentOutputDescriptor)).clone() })) as *mut c_void
 170 }
 171 #[no_mangle]
 172 /// Creates a copy of the DelayedPaymentOutputDescriptor
 173 pub extern "C" fn DelayedPaymentOutputDescriptor_clone(orig: &DelayedPaymentOutputDescriptor) -> DelayedPaymentOutputDescriptor {
 174         orig.clone()
 175 }
 176
 177 use lightning::chain::keysinterface::StaticPaymentOutputDescriptor as nativeStaticPaymentOutputDescriptorImport;
 178 type nativeStaticPaymentOutputDescriptor = nativeStaticPaymentOutputDescriptorImport;
 179
 180 /// Information about a spendable output to our \"payment key\". See
 181 /// SpendableOutputDescriptor::StaticPaymentOutput for more details on how to spend this.
 182 #[must_use]
 183 #[repr(C)]
 184 pub struct StaticPaymentOutputDescriptor {
 185         /// A pointer to the opaque Rust object.
 186
 187         /// Nearly everywhere, inner must be non-null, however in places where
 188         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 189         pub inner: *mut nativeStaticPaymentOutputDescriptor,
 190         /// Indicates that this is the only struct which contains the same pointer.
 191
 192         /// Rust functions which take ownership of an object provided via an argument require
 193         /// this to be true and invalidate the object pointed to by inner.
 194         pub is_owned: bool,
 195 }
 196
 197 impl Drop for StaticPaymentOutputDescriptor {
 198         fn drop(&mut self) {
 199                 if self.is_owned && !<*mut nativeStaticPaymentOutputDescriptor>::is_null(self.inner) {
 200                         let _ = unsafe { Box::from_raw(self.inner) };
 201                 }
 202         }
 203 }
 204 /// Frees any resources used by the StaticPaymentOutputDescriptor, if is_owned is set and inner is non-NULL.
 205 #[no_mangle]
 206 pub extern "C" fn StaticPaymentOutputDescriptor_free(this_obj: StaticPaymentOutputDescriptor) { }
 207 #[allow(unused)]
 208 /// Used only if an object of this type is returned as a trait impl by a method
 209 extern "C" fn StaticPaymentOutputDescriptor_free_void(this_ptr: *mut c_void) {
 210         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeStaticPaymentOutputDescriptor); }
 211 }
 212 #[allow(unused)]
 213 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 214 impl StaticPaymentOutputDescriptor {
 215         pub(crate) fn take_inner(mut self) -> *mut nativeStaticPaymentOutputDescriptor {
 216                 assert!(self.is_owned);
 217                 let ret = self.inner;
 218                 self.inner = std::ptr::null_mut();
 219                 ret
 220         }
 221 }
 222 /// The outpoint which is spendable
 223 #[no_mangle]
 224 pub extern "C" fn StaticPaymentOutputDescriptor_get_outpoint(this_ptr: &StaticPaymentOutputDescriptor) -> crate::lightning::chain::transaction::OutPoint {
 225         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.outpoint;
 226         crate::lightning::chain::transaction::OutPoint { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
 227 }
 228 /// The outpoint which is spendable
 229 #[no_mangle]
 230 pub extern "C" fn StaticPaymentOutputDescriptor_set_outpoint(this_ptr: &mut StaticPaymentOutputDescriptor, mut val: crate::lightning::chain::transaction::OutPoint) {
 231         unsafe { &mut *this_ptr.inner }.outpoint = *unsafe { Box::from_raw(val.take_inner()) };
 232 }
 233 /// The output which is referenced by the given outpoint
 234 #[no_mangle]
 235 pub extern "C" fn StaticPaymentOutputDescriptor_set_output(this_ptr: &mut StaticPaymentOutputDescriptor, mut val: crate::c_types::TxOut) {
 236         unsafe { &mut *this_ptr.inner }.output = val.into_rust();
 237 }
 238 /// Arbitrary identification information returned by a call to
 239 /// `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
 240 /// the channel to spend the output.
 241 #[no_mangle]
 242 pub extern "C" fn StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: &StaticPaymentOutputDescriptor) -> *const [u8; 32] {
 243         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_keys_id;
 244         inner_val
 245 }
 246 /// Arbitrary identification information returned by a call to
 247 /// `Sign::channel_keys_id()`. This may be useful in re-deriving keys used in
 248 /// the channel to spend the output.
 249 #[no_mangle]
 250 pub extern "C" fn StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: &mut StaticPaymentOutputDescriptor, mut val: crate::c_types::ThirtyTwoBytes) {
 251         unsafe { &mut *this_ptr.inner }.channel_keys_id = val.data;
 252 }
 253 /// The value of the channel which this transactions spends.
 254 #[no_mangle]
 255 pub extern "C" fn StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: &StaticPaymentOutputDescriptor) -> u64 {
 256         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_value_satoshis;
 257         *inner_val
 258 }
 259 /// The value of the channel which this transactions spends.
 260 #[no_mangle]
 261 pub extern "C" fn StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: &mut StaticPaymentOutputDescriptor, mut val: u64) {
 262         unsafe { &mut *this_ptr.inner }.channel_value_satoshis = val;
 263 }
 264 /// Constructs a new StaticPaymentOutputDescriptor given each field
 265 #[must_use]
 266 #[no_mangle]
 267 pub extern "C" fn StaticPaymentOutputDescriptor_new(mut outpoint_arg: crate::lightning::chain::transaction::OutPoint, mut output_arg: crate::c_types::TxOut, mut channel_keys_id_arg: crate::c_types::ThirtyTwoBytes, mut channel_value_satoshis_arg: u64) -> StaticPaymentOutputDescriptor {
 268         StaticPaymentOutputDescriptor { inner: Box::into_raw(Box::new(nativeStaticPaymentOutputDescriptor {
 269                 outpoint: *unsafe { Box::from_raw(outpoint_arg.take_inner()) },
 270                 output: output_arg.into_rust(),
 271                 channel_keys_id: channel_keys_id_arg.data,
 272                 channel_value_satoshis: channel_value_satoshis_arg,
 273         })), is_owned: true }
 274 }
 275 impl Clone for StaticPaymentOutputDescriptor {
 276         fn clone(&self) -> Self {
 277                 Self {
 278                         inner: if <*mut nativeStaticPaymentOutputDescriptor>::is_null(self.inner) { std::ptr::null_mut() } else {
 279                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
 280                         is_owned: true,
 281                 }
 282         }
 283 }
 284 #[allow(unused)]
 285 /// Used only if an object of this type is returned as a trait impl by a method
 286 pub(crate) extern "C" fn StaticPaymentOutputDescriptor_clone_void(this_ptr: *const c_void) -> *mut c_void {
 287         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeStaticPaymentOutputDescriptor)).clone() })) as *mut c_void
 288 }
 289 #[no_mangle]
 290 /// Creates a copy of the StaticPaymentOutputDescriptor
 291 pub extern "C" fn StaticPaymentOutputDescriptor_clone(orig: &StaticPaymentOutputDescriptor) -> StaticPaymentOutputDescriptor {
 292         orig.clone()
 293 }
 294 /// When on-chain outputs are created by rust-lightning (which our counterparty is not able to
 295 /// claim at any point in the future) an event is generated which you must track and be able to
 296 /// spend on-chain. The information needed to do this is provided in this enum, including the
 297 /// outpoint describing which txid and output index is available, the full output which exists at
 298 /// that txid/index, and any keys or other information required to sign.
 299 #[must_use]
 300 #[derive(Clone)]
 301 #[repr(C)]
 302 pub enum SpendableOutputDescriptor {
 303         /// An output to a script which was provided via KeysInterface directly, either from
 304         /// `get_destination_script()` or `get_shutdown_pubkey()`, thus you should already know how to
 305         /// spend it. No secret keys are provided as rust-lightning was never given any key.
 306         /// These may include outputs from a transaction punishing our counterparty or claiming an HTLC
 307         /// on-chain using the payment preimage or after it has timed out.
 308         StaticOutput {
 309                 /// The outpoint which is spendable
 310                 outpoint: crate::lightning::chain::transaction::OutPoint,
 311                 /// The output which is referenced by the given outpoint.
 312                 output: crate::c_types::TxOut,
 313         },
 314         /// An output to a P2WSH script which can be spent with a single signature after a CSV delay.
 315         ///
 316         /// The witness in the spending input should be:
 317         /// <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
 318         ///
 319         /// Note that the nSequence field in the spending input must be set to to_self_delay
 320         /// (which means the transaction is not broadcastable until at least to_self_delay
 321         /// blocks after the outpoint confirms).
 322         ///
 323         /// These are generally the result of a \"revocable\" output to us, spendable only by us unless
 324         /// it is an output from an old state which we broadcast (which should never happen).
 325         ///
 326         /// To derive the delayed_payment key which is used to sign for this input, you must pass the
 327         /// holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
 328         /// Sign::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
 329         /// chan_utils::derive_private_key. The public key can be generated without the secret key
 330         /// using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
 331         /// Sign::pubkeys().
 332         ///
 333         /// To derive the revocation_pubkey provided here (which is used in the witness
 334         /// script generation), you must pass the counterparty revocation_basepoint (which appears in the
 335         /// call to Sign::ready_channel) and the provided per_commitment point
 336         /// to chan_utils::derive_public_revocation_key.
 337         ///
 338         /// The witness script which is hashed and included in the output script_pubkey may be
 339         /// regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
 340         /// (derived as above), and the to_self_delay contained here to
 341         /// chan_utils::get_revokeable_redeemscript.
 342         DelayedPaymentOutput(crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor),
 343         /// An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
 344         /// corresponds to the public key in Sign::pubkeys().payment_point).
 345         /// The witness in the spending input, is, thus, simply:
 346         /// <BIP 143 signature> <payment key>
 347         ///
 348         /// These are generally the result of our counterparty having broadcast the current state,
 349         /// allowing us to claim the non-HTLC-encumbered outputs immediately.
 350         StaticPaymentOutput(crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor),
 351 }
 352 use lightning::chain::keysinterface::SpendableOutputDescriptor as nativeSpendableOutputDescriptor;
 353 impl SpendableOutputDescriptor {
 354         #[allow(unused)]
 355         pub(crate) fn to_native(&self) -> nativeSpendableOutputDescriptor {
 356                 match self {
 357                         SpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => {
 358                                 let mut outpoint_nonref = (*outpoint).clone();
 359                                 let mut output_nonref = (*output).clone();
 360                                 nativeSpendableOutputDescriptor::StaticOutput {
 361                                         outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_inner()) },
 362                                         output: output_nonref.into_rust(),
 363                                 }
 364                         },
 365                         SpendableOutputDescriptor::DelayedPaymentOutput (ref a, ) => {
 366                                 let mut a_nonref = (*a).clone();
 367                                 nativeSpendableOutputDescriptor::DelayedPaymentOutput (
 368                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 369                                 )
 370                         },
 371                         SpendableOutputDescriptor::StaticPaymentOutput (ref a, ) => {
 372                                 let mut a_nonref = (*a).clone();
 373                                 nativeSpendableOutputDescriptor::StaticPaymentOutput (
 374                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 375                                 )
 376                         },
 377                 }
 378         }
 379         #[allow(unused)]
 380         pub(crate) fn into_native(self) -> nativeSpendableOutputDescriptor {
 381                 match self {
 382                         SpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => {
 383                                 nativeSpendableOutputDescriptor::StaticOutput {
 384                                         outpoint: *unsafe { Box::from_raw(outpoint.take_inner()) },
 385                                         output: output.into_rust(),
 386                                 }
 387                         },
 388                         SpendableOutputDescriptor::DelayedPaymentOutput (mut a, ) => {
 389                                 nativeSpendableOutputDescriptor::DelayedPaymentOutput (
 390                                         *unsafe { Box::from_raw(a.take_inner()) },
 391                                 )
 392                         },
 393                         SpendableOutputDescriptor::StaticPaymentOutput (mut a, ) => {
 394                                 nativeSpendableOutputDescriptor::StaticPaymentOutput (
 395                                         *unsafe { Box::from_raw(a.take_inner()) },
 396                                 )
 397                         },
 398                 }
 399         }
 400         #[allow(unused)]
 401         pub(crate) fn from_native(native: &nativeSpendableOutputDescriptor) -> Self {
 402                 match native {
 403                         nativeSpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => {
 404                                 let mut outpoint_nonref = (*outpoint).clone();
 405                                 let mut output_nonref = (*output).clone();
 406                                 SpendableOutputDescriptor::StaticOutput {
 407                                         outpoint: crate::lightning::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true },
 408                                         output: crate::c_types::TxOut::from_rust(output_nonref),
 409                                 }
 410                         },
 411                         nativeSpendableOutputDescriptor::DelayedPaymentOutput (ref a, ) => {
 412                                 let mut a_nonref = (*a).clone();
 413                                 SpendableOutputDescriptor::DelayedPaymentOutput (
 414                                         crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor { inner: Box::into_raw(Box::new(a_nonref)), is_owned: true },
 415                                 )
 416                         },
 417                         nativeSpendableOutputDescriptor::StaticPaymentOutput (ref a, ) => {
 418                                 let mut a_nonref = (*a).clone();
 419                                 SpendableOutputDescriptor::StaticPaymentOutput (
 420                                         crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor { inner: Box::into_raw(Box::new(a_nonref)), is_owned: true },
 421                                 )
 422                         },
 423                 }
 424         }
 425         #[allow(unused)]
 426         pub(crate) fn native_into(native: nativeSpendableOutputDescriptor) -> Self {
 427                 match native {
 428                         nativeSpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => {
 429                                 SpendableOutputDescriptor::StaticOutput {
 430                                         outpoint: crate::lightning::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true },
 431                                         output: crate::c_types::TxOut::from_rust(output),
 432                                 }
 433                         },
 434                         nativeSpendableOutputDescriptor::DelayedPaymentOutput (mut a, ) => {
 435                                 SpendableOutputDescriptor::DelayedPaymentOutput (
 436                                         crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor { inner: Box::into_raw(Box::new(a)), is_owned: true },
 437                                 )
 438                         },
 439                         nativeSpendableOutputDescriptor::StaticPaymentOutput (mut a, ) => {
 440                                 SpendableOutputDescriptor::StaticPaymentOutput (
 441                                         crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor { inner: Box::into_raw(Box::new(a)), is_owned: true },
 442                                 )
 443                         },
 444                 }
 445         }
 446 }
 447 /// Frees any resources used by the SpendableOutputDescriptor
 448 #[no_mangle]
 449 pub extern "C" fn SpendableOutputDescriptor_free(this_ptr: SpendableOutputDescriptor) { }
 450 /// Creates a copy of the SpendableOutputDescriptor
 451 #[no_mangle]
 452 pub extern "C" fn SpendableOutputDescriptor_clone(orig: &SpendableOutputDescriptor) -> SpendableOutputDescriptor {
 453         orig.clone()
 454 }
 455 #[no_mangle]
 456 /// Serialize the SpendableOutputDescriptor object into a byte array which can be read by SpendableOutputDescriptor_read
 457 pub extern "C" fn SpendableOutputDescriptor_write(obj: &SpendableOutputDescriptor) -> crate::c_types::derived::CVec_u8Z {
 458         crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
 459 }
 460 #[no_mangle]
 461 /// Read a SpendableOutputDescriptor from a byte array, created by SpendableOutputDescriptor_write
 462 pub extern "C" fn SpendableOutputDescriptor_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SpendableOutputDescriptorDecodeErrorZ {
 463         let res = crate::c_types::deserialize_obj(ser);
 464         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::chain::keysinterface::SpendableOutputDescriptor::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
 465         local_res
 466 }
 467 /// A trait to sign lightning channel transactions as described in BOLT 3.
 468 ///
 469 /// Signing services could be implemented on a hardware wallet. In this case,
 470 /// the current Sign would be a front-end on top of a communication
 471 /// channel connected to your secure device and lightning key material wouldn't
 472 /// reside on a hot server. Nevertheless, a this deployment would still need
 473 /// to trust the ChannelManager to avoid loss of funds as this latest component
 474 /// could ask to sign commitment transaction with HTLCs paying to attacker pubkeys.
 475 ///
 476 /// A more secure iteration would be to use hashlock (or payment points) to pair
 477 /// invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager
 478 /// at the price of more state and computation on the hardware wallet side. In the future,
 479 /// we are looking forward to design such interface.
 480 ///
 481 /// In any case, ChannelMonitor or fallback watchtowers are always going to be trusted
 482 /// to act, as liveness and breach reply correctness are always going to be hard requirements
 483 /// of LN security model, orthogonal of key management issues.
 484 #[repr(C)]
 485 pub struct BaseSign {
 486         /// An opaque pointer which is passed to your function implementations as an argument.
 487         /// This has no meaning in the LDK, and can be NULL or any other value.
 488         pub this_arg: *mut c_void,
 489         /// Gets the per-commitment point for a specific commitment number
 490         ///
 491         /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
 492         #[must_use]
 493         pub get_per_commitment_point: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::PublicKey,
 494         /// Gets the commitment secret for a specific commitment number as part of the revocation process
 495         ///
 496         /// An external signer implementation should error here if the commitment was already signed
 497         /// and should refuse to sign it in the future.
 498         ///
 499         /// May be called more than once for the same index.
 500         ///
 501         /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
 502         #[must_use]
 503         pub release_commitment_secret: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::ThirtyTwoBytes,
 504         /// Gets the holder's channel public keys and basepoints
 505         pub pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys,
 506         /// Fill in the pubkeys field as a reference to it will be given to Rust after this returns
 507         /// Note that this takes a pointer to this object, not the this_ptr like other methods do
 508         /// This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
 509         pub set_pubkeys: Option<extern "C" fn(&BaseSign)>,
 510         /// Gets an arbitrary identifier describing the set of keys which are provided back to you in
 511         /// some SpendableOutputDescriptor types. This should be sufficient to identify this
 512         /// Sign object uniquely and lookup or re-derive its keys.
 513         #[must_use]
 514         pub channel_keys_id: extern "C" fn (this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes,
 515         /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
 516         ///
 517         /// Note that if signing fails or is rejected, the channel will be force-closed.
 518         #[must_use]
 519         pub sign_counterparty_commitment: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::CommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ,
 520         /// Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
 521         /// This will only ever be called with a non-revoked commitment_tx.  This will be called with the
 522         /// latest commitment_tx when we initiate a force-close.
 523         /// This will be called with the previous latest, just to get claiming HTLC signatures, if we are
 524         /// reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
 525         /// the latest.
 526         /// This may be called multiple times for the same transaction.
 527         ///
 528         /// An external signer implementation should check that the commitment has not been revoked.
 529         ///
 530         /// May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
 531         #[must_use]
 532         pub sign_holder_commitment_and_htlcs: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::HolderCommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ,
 533         /// Create a signature for the given input in a transaction spending an HTLC or commitment
 534         /// transaction output when our counterparty broadcasts an old state.
 535         ///
 536         /// A justice transaction may claim multiples outputs at the same time if timelocks are
 537         /// similar, but only a signature for the input at index `input` should be signed for here.
 538         /// It may be called multiples time for same output(s) if a fee-bump is needed with regards
 539         /// to an upcoming timelock expiration.
 540         ///
 541         /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 542         ///
 543         /// per_commitment_key is revocation secret which was provided by our counterparty when they
 544         /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 545         /// not allow the spending of any funds by itself (you need our holder revocation_secret to do
 546         /// so).
 547         ///
 548         /// htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
 549         /// changing the format of the witness script (which is committed to in the BIP 143
 550         /// signatures).
 551         #[must_use]
 552         pub sign_justice_transaction: 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_SignatureNoneZ,
 553         /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
 554         /// transaction, either offered or received.
 555         ///
 556         /// Such a transaction may claim multiples offered outputs at same time if we know the
 557         /// preimage for each when we create it, but only the input at index `input` should be
 558         /// signed for here. It may be called multiple times for same output(s) if a fee-bump is
 559         /// needed with regards to an upcoming timelock expiration.
 560         ///
 561         /// Witness_script is either a offered or received script as defined in BOLT3 for HTLC
 562         /// outputs.
 563         ///
 564         /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 565         ///
 566         /// Per_commitment_point is the dynamic point corresponding to the channel state
 567         /// detected onchain. It has been generated by our counterparty and is used to derive
 568         /// channel state keys, which are then included in the witness script and committed to in the
 569         /// BIP 143 signature.
 570         #[must_use]
 571         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_SignatureNoneZ,
 572         /// Create a signature for a (proposed) closing transaction.
 573         ///
 574         /// Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
 575         /// chosen to forgo their output as dust.
 576         #[must_use]
 577         pub sign_closing_transaction: extern "C" fn (this_arg: *const c_void, closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ,
 578         /// Signs a channel announcement message with our funding key, proving it comes from one
 579         /// of the channel participants.
 580         ///
 581         /// Note that if this fails or is rejected, the channel will not be publicly announced and
 582         /// our counterparty may (though likely will not) close the channel on us for violating the
 583         /// protocol.
 584         #[must_use]
 585         pub sign_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ,
 586         /// Set the counterparty static channel data, including basepoints,
 587         /// counterparty_selected/holder_selected_contest_delay and funding outpoint.
 588         /// This is done as soon as the funding outpoint is known.  Since these are static channel data,
 589         /// they MUST NOT be allowed to change to different values once set.
 590         ///
 591         /// channel_parameters.is_populated() MUST be true.
 592         ///
 593         /// We bind holder_selected_contest_delay late here for API convenience.
 594         ///
 595         /// Will be called before any signatures are applied.
 596         pub ready_channel: extern "C" fn (this_arg: *mut c_void, channel_parameters: &crate::lightning::ln::chan_utils::ChannelTransactionParameters),
 597         /// Frees any resources associated with this object given its this_arg pointer.
 598         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 599         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 600 }
 601 unsafe impl Send for BaseSign {}
 602
 603 use lightning::chain::keysinterface::BaseSign as rustBaseSign;
 604 impl rustBaseSign for BaseSign {
 605         fn get_per_commitment_point(&self, idx: u64, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::key::PublicKey {
 606                 let mut ret = (self.get_per_commitment_point)(self.this_arg, idx);
 607                 ret.into_rust()
 608         }
 609         fn release_commitment_secret(&self, idx: u64) -> [u8; 32] {
 610                 let mut ret = (self.release_commitment_secret)(self.this_arg, idx);
 611                 ret.data
 612         }
 613         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 614                 if let Some(f) = self.set_pubkeys {
 615                         (f)(&self);
 616                 }
 617                 unsafe { &*self.pubkeys.inner }
 618         }
 619         fn channel_keys_id(&self) -> [u8; 32] {
 620                 let mut ret = (self.channel_keys_id)(self.this_arg);
 621                 ret.data
 622         }
 623         fn sign_counterparty_commitment(&self, commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 624                 let mut ret = (self.sign_counterparty_commitment)(self.this_arg, &crate::lightning::ln::chan_utils::CommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 625                 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)) })*/ })};
 626                 local_ret
 627         }
 628         fn sign_holder_commitment_and_htlcs(&self, commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 629                 let mut ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 630                 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)) })*/ })};
 631                 local_ret
 632         }
 633         fn sign_justice_transaction(&self, justice_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_key: &bitcoin::secp256k1::key::SecretKey, htlc: &Option<lightning::ln::chan_utils::HTLCOutputInCommitment>, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 634                 let mut local_htlc = &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { (if htlc.is_none() { std::ptr::null() } else {  { (htlc.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false };
 635                 let mut ret = (self.sign_justice_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref(), local_htlc);
 636                 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)) })*/ })};
 637                 local_ret
 638         }
 639         fn sign_counterparty_htlc_transaction(&self, htlc_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_point: &bitcoin::secp256k1::key::PublicKey, htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 640                 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 { (htlc as *const _) as *mut _ }, is_owned: false });
 641                 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)) })*/ })};
 642                 local_ret
 643         }
 644         fn sign_closing_transaction(&self, closing_tx: &bitcoin::blockdata::transaction::Transaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 645                 let mut ret = (self.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(closing_tx));
 646                 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)) })*/ })};
 647                 local_ret
 648         }
 649         fn sign_channel_announcement(&self, msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 650                 let mut ret = (self.sign_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
 651                 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)) })*/ })};
 652                 local_ret
 653         }
 654         fn ready_channel(&mut self, channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 655                 (self.ready_channel)(self.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { (channel_parameters as *const _) as *mut _ }, is_owned: false })
 656         }
 657 }
 658
 659 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 660 // directly as a Deref trait in higher-level structs:
 661 impl std::ops::Deref for BaseSign {
 662         type Target = Self;
 663         fn deref(&self) -> &Self {
 664                 self
 665         }
 666 }
 667 /// Calls the free function if one is set
 668 #[no_mangle]
 669 pub extern "C" fn BaseSign_free(this_ptr: BaseSign) { }
 670 impl Drop for BaseSign {
 671         fn drop(&mut self) {
 672                 if let Some(f) = self.free {
 673                         f(self.this_arg);
 674                 }
 675         }
 676 }
 677 /// A cloneable signer.
 678 ///
 679 /// Although we require signers to be cloneable, it may be useful for developers to be able to use
 680 /// signers in an un-sized way, for example as `dyn BaseSign`. Therefore we separate the Clone trait,
 681 /// which implies Sized, into this derived trait.
 682 #[repr(C)]
 683 pub struct Sign {
 684         /// An opaque pointer which is passed to your function implementations as an argument.
 685         /// This has no meaning in the LDK, and can be NULL or any other value.
 686         pub this_arg: *mut c_void,
 687         /// Implementation of BaseSign for this object.
 688         pub BaseSign: crate::lightning::chain::keysinterface::BaseSign,
 689         /// Creates a copy of the BaseSign, for a copy of this Sign.
 690         /// Because BaseSign doesn't natively support copying itself, you have to provide a full copy implementation here.
 691         pub BaseSign_clone: extern "C" fn (orig_BaseSign: &BaseSign) -> BaseSign,
 692         /// Serialize the object into a byte array
 693         pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 694         /// Creates a copy of the object pointed to by this_arg, for a copy of this Sign.
 695         /// Note that the ultimate copy of the Sign will have all function pointers the same as the original.
 696         /// May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new Sign.
 697         pub clone: Option<extern "C" fn (this_arg: *const c_void) -> *mut c_void>,
 698         /// Frees any resources associated with this object given its this_arg pointer.
 699         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 700         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 701 }
 702 impl lightning::chain::keysinterface::BaseSign for Sign {
 703         fn get_per_commitment_point(&self, idx: u64, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::key::PublicKey {
 704                 let mut ret = (self.BaseSign.get_per_commitment_point)(self.this_arg, idx);
 705                 ret.into_rust()
 706         }
 707         fn release_commitment_secret(&self, idx: u64) -> [u8; 32] {
 708                 let mut ret = (self.BaseSign.release_commitment_secret)(self.this_arg, idx);
 709                 ret.data
 710         }
 711         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 712                 if let Some(f) = self.BaseSign.set_pubkeys {
 713                         (f)(&self.BaseSign);
 714                 }
 715                 unsafe { &*self.BaseSign.pubkeys.inner }
 716         }
 717         fn channel_keys_id(&self) -> [u8; 32] {
 718                 let mut ret = (self.BaseSign.channel_keys_id)(self.this_arg);
 719                 ret.data
 720         }
 721         fn sign_counterparty_commitment(&self, commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 722                 let mut ret = (self.BaseSign.sign_counterparty_commitment)(self.this_arg, &crate::lightning::ln::chan_utils::CommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 723                 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)) })*/ })};
 724                 local_ret
 725         }
 726         fn sign_holder_commitment_and_htlcs(&self, commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 727                 let mut ret = (self.BaseSign.sign_holder_commitment_and_htlcs)(self.this_arg, &crate::lightning::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 728                 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)) })*/ })};
 729                 local_ret
 730         }
 731         fn sign_justice_transaction(&self, justice_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_key: &bitcoin::secp256k1::key::SecretKey, htlc: &Option<lightning::ln::chan_utils::HTLCOutputInCommitment>, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 732                 let mut local_htlc = &crate::lightning::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { (if htlc.is_none() { std::ptr::null() } else {  { (htlc.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false };
 733                 let mut ret = (self.BaseSign.sign_justice_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(justice_tx), input, amount, per_commitment_key.as_ref(), local_htlc);
 734                 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)) })*/ })};
 735                 local_ret
 736         }
 737         fn sign_counterparty_htlc_transaction(&self, htlc_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_point: &bitcoin::secp256k1::key::PublicKey, htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 738                 let mut ret = (self.BaseSign.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 { (htlc as *const _) as *mut _ }, is_owned: false });
 739                 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)) })*/ })};
 740                 local_ret
 741         }
 742         fn sign_closing_transaction(&self, closing_tx: &bitcoin::blockdata::transaction::Transaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 743                 let mut ret = (self.BaseSign.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(closing_tx));
 744                 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)) })*/ })};
 745                 local_ret
 746         }
 747         fn sign_channel_announcement(&self, msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 748                 let mut ret = (self.BaseSign.sign_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
 749                 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)) })*/ })};
 750                 local_ret
 751         }
 752         fn ready_channel(&mut self, channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 753                 (self.BaseSign.ready_channel)(self.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { (channel_parameters as *const _) as *mut _ }, is_owned: false })
 754         }
 755 }
 756 unsafe impl Send for Sign {}
 757 impl lightning::util::ser::Writeable for Sign {
 758         fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 759                 let vec = (self.write)(self.this_arg);
 760                 w.write_all(vec.as_slice())
 761         }
 762 }
 763 #[no_mangle]
 764 /// Creates a copy of a Sign
 765 pub extern "C" fn Sign_clone(orig: &Sign) -> Sign {
 766         Sign {
 767                 this_arg: if let Some(f) = orig.clone { (f)(orig.this_arg) } else { orig.this_arg },
 768                 BaseSign: (orig.BaseSign_clone)(&orig.BaseSign),
 769                 BaseSign_clone: orig.BaseSign_clone,
 770                 write: Clone::clone(&orig.write),
 771                 clone: Clone::clone(&orig.clone),
 772                 free: Clone::clone(&orig.free),
 773         }
 774 }
 775 impl Clone for Sign {
 776         fn clone(&self) -> Self {
 777                 Sign_clone(self)
 778         }
 779 }
 780
 781 use lightning::chain::keysinterface::Sign as rustSign;
 782 impl rustSign for Sign {
 783 }
 784
 785 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 786 // directly as a Deref trait in higher-level structs:
 787 impl std::ops::Deref for Sign {
 788         type Target = Self;
 789         fn deref(&self) -> &Self {
 790                 self
 791         }
 792 }
 793 /// Calls the free function if one is set
 794 #[no_mangle]
 795 pub extern "C" fn Sign_free(this_ptr: Sign) { }
 796 impl Drop for Sign {
 797         fn drop(&mut self) {
 798                 if let Some(f) = self.free {
 799                         f(self.this_arg);
 800                 }
 801         }
 802 }
 803 /// A trait to describe an object which can get user secrets and key material.
 804 #[repr(C)]
 805 pub struct KeysInterface {
 806         /// An opaque pointer which is passed to your function implementations as an argument.
 807         /// This has no meaning in the LDK, and can be NULL or any other value.
 808         pub this_arg: *mut c_void,
 809         /// Get node secret key (aka node_id or network_key).
 810         ///
 811         /// This method must return the same value each time it is called.
 812         #[must_use]
 813         pub get_node_secret: extern "C" fn (this_arg: *const c_void) -> crate::c_types::SecretKey,
 814         /// Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 815         ///
 816         /// This method should return a different value each time it is called, to avoid linking
 817         /// on-chain funds across channels as controlled to the same user.
 818         #[must_use]
 819         pub get_destination_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 820         /// Get a public key which we will send funds to (in the form of a P2WPKH output) when closing
 821         /// a channel.
 822         ///
 823         /// This method should return a different value each time it is called, to avoid linking
 824         /// on-chain funds across channels as controlled to the same user.
 825         #[must_use]
 826         pub get_shutdown_pubkey: extern "C" fn (this_arg: *const c_void) -> crate::c_types::PublicKey,
 827         /// Get a new set of Sign for per-channel secrets. These MUST be unique even if you
 828         /// restarted with some stale data!
 829         ///
 830         /// This method must return a different value each time it is called.
 831         #[must_use]
 832         pub get_channel_signer: extern "C" fn (this_arg: *const c_void, inbound: bool, channel_value_satoshis: u64) -> crate::lightning::chain::keysinterface::Sign,
 833         /// Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
 834         /// onion packets and for temporary channel IDs. There is no requirement that these be
 835         /// persisted anywhere, though they must be unique across restarts.
 836         ///
 837         /// This method must return a different value each time it is called.
 838         #[must_use]
 839         pub get_secure_random_bytes: extern "C" fn (this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes,
 840         /// Reads a `Signer` for this `KeysInterface` from the given input stream.
 841         /// This is only called during deserialization of other objects which contain
 842         /// `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
 843         /// The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
 844         /// contain no versioning scheme. You may wish to include your own version prefix and ensure
 845         /// you've read all of the provided bytes to ensure no corruption occurred.
 846         #[must_use]
 847         pub read_chan_signer: extern "C" fn (this_arg: *const c_void, reader: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SignDecodeErrorZ,
 848         /// Frees any resources associated with this object given its this_arg pointer.
 849         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 850         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 851 }
 852 unsafe impl Send for KeysInterface {}
 853 unsafe impl Sync for KeysInterface {}
 854
 855 use lightning::chain::keysinterface::KeysInterface as rustKeysInterface;
 856 impl rustKeysInterface for KeysInterface {
 857         type Signer = crate::lightning::chain::keysinterface::Sign;
 858         fn get_node_secret(&self) -> bitcoin::secp256k1::key::SecretKey {
 859                 let mut ret = (self.get_node_secret)(self.this_arg);
 860                 ret.into_rust()
 861         }
 862         fn get_destination_script(&self) -> bitcoin::blockdata::script::Script {
 863                 let mut ret = (self.get_destination_script)(self.this_arg);
 864                 ::bitcoin::blockdata::script::Script::from(ret.into_rust())
 865         }
 866         fn get_shutdown_pubkey(&self) -> bitcoin::secp256k1::key::PublicKey {
 867                 let mut ret = (self.get_shutdown_pubkey)(self.this_arg);
 868                 ret.into_rust()
 869         }
 870         fn get_channel_signer(&self, inbound: bool, channel_value_satoshis: u64) -> crate::lightning::chain::keysinterface::Sign {
 871                 let mut ret = (self.get_channel_signer)(self.this_arg, inbound, channel_value_satoshis);
 872                 ret
 873         }
 874         fn get_secure_random_bytes(&self) -> [u8; 32] {
 875                 let mut ret = (self.get_secure_random_bytes)(self.this_arg);
 876                 ret.data
 877         }
 878         fn read_chan_signer(&self, reader: &[u8]) -> Result<crate::lightning::chain::keysinterface::Sign, lightning::ln::msgs::DecodeError> {
 879                 let mut local_reader = crate::c_types::u8slice::from_slice(reader);
 880                 let mut ret = (self.read_chan_signer)(self.this_arg, local_reader);
 881                 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((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
 882                 local_ret
 883         }
 884 }
 885
 886 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 887 // directly as a Deref trait in higher-level structs:
 888 impl std::ops::Deref for KeysInterface {
 889         type Target = Self;
 890         fn deref(&self) -> &Self {
 891                 self
 892         }
 893 }
 894 /// Calls the free function if one is set
 895 #[no_mangle]
 896 pub extern "C" fn KeysInterface_free(this_ptr: KeysInterface) { }
 897 impl Drop for KeysInterface {
 898         fn drop(&mut self) {
 899                 if let Some(f) = self.free {
 900                         f(self.this_arg);
 901                 }
 902         }
 903 }
 904
 905 use lightning::chain::keysinterface::InMemorySigner as nativeInMemorySignerImport;
 906 type nativeInMemorySigner = nativeInMemorySignerImport;
 907
 908 /// A simple implementation of Sign that just keeps the private keys in memory.
 909 ///
 910 /// This implementation performs no policy checks and is insufficient by itself as
 911 /// a secure external signer.
 912 #[must_use]
 913 #[repr(C)]
 914 pub struct InMemorySigner {
 915         /// A pointer to the opaque Rust object.
 916
 917         /// Nearly everywhere, inner must be non-null, however in places where
 918         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 919         pub inner: *mut nativeInMemorySigner,
 920         /// Indicates that this is the only struct which contains the same pointer.
 921
 922         /// Rust functions which take ownership of an object provided via an argument require
 923         /// this to be true and invalidate the object pointed to by inner.
 924         pub is_owned: bool,
 925 }
 926
 927 impl Drop for InMemorySigner {
 928         fn drop(&mut self) {
 929                 if self.is_owned && !<*mut nativeInMemorySigner>::is_null(self.inner) {
 930                         let _ = unsafe { Box::from_raw(self.inner) };
 931                 }
 932         }
 933 }
 934 /// Frees any resources used by the InMemorySigner, if is_owned is set and inner is non-NULL.
 935 #[no_mangle]
 936 pub extern "C" fn InMemorySigner_free(this_obj: InMemorySigner) { }
 937 #[allow(unused)]
 938 /// Used only if an object of this type is returned as a trait impl by a method
 939 extern "C" fn InMemorySigner_free_void(this_ptr: *mut c_void) {
 940         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInMemorySigner); }
 941 }
 942 #[allow(unused)]
 943 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 944 impl InMemorySigner {
 945         pub(crate) fn take_inner(mut self) -> *mut nativeInMemorySigner {
 946                 assert!(self.is_owned);
 947                 let ret = self.inner;
 948                 self.inner = std::ptr::null_mut();
 949                 ret
 950         }
 951 }
 952 /// Private key of anchor tx
 953 #[no_mangle]
 954 pub extern "C" fn InMemorySigner_get_funding_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 955         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_key;
 956         inner_val.as_ref()
 957 }
 958 /// Private key of anchor tx
 959 #[no_mangle]
 960 pub extern "C" fn InMemorySigner_set_funding_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 961         unsafe { &mut *this_ptr.inner }.funding_key = val.into_rust();
 962 }
 963 /// Holder secret key for blinded revocation pubkey
 964 #[no_mangle]
 965 pub extern "C" fn InMemorySigner_get_revocation_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 966         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_base_key;
 967         inner_val.as_ref()
 968 }
 969 /// Holder secret key for blinded revocation pubkey
 970 #[no_mangle]
 971 pub extern "C" fn InMemorySigner_set_revocation_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 972         unsafe { &mut *this_ptr.inner }.revocation_base_key = val.into_rust();
 973 }
 974 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 975 #[no_mangle]
 976 pub extern "C" fn InMemorySigner_get_payment_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 977         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_key;
 978         inner_val.as_ref()
 979 }
 980 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 981 #[no_mangle]
 982 pub extern "C" fn InMemorySigner_set_payment_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 983         unsafe { &mut *this_ptr.inner }.payment_key = val.into_rust();
 984 }
 985 /// Holder secret key used in HTLC tx
 986 #[no_mangle]
 987 pub extern "C" fn InMemorySigner_get_delayed_payment_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 988         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_base_key;
 989         inner_val.as_ref()
 990 }
 991 /// Holder secret key used in HTLC tx
 992 #[no_mangle]
 993 pub extern "C" fn InMemorySigner_set_delayed_payment_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 994         unsafe { &mut *this_ptr.inner }.delayed_payment_base_key = val.into_rust();
 995 }
 996 /// Holder htlc secret key used in commitment tx htlc outputs
 997 #[no_mangle]
 998 pub extern "C" fn InMemorySigner_get_htlc_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 999         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_base_key;
1000         inner_val.as_ref()
1001 }
1002 /// Holder htlc secret key used in commitment tx htlc outputs
1003 #[no_mangle]
1004 pub extern "C" fn InMemorySigner_set_htlc_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
1005         unsafe { &mut *this_ptr.inner }.htlc_base_key = val.into_rust();
1006 }
1007 /// Commitment seed
1008 #[no_mangle]
1009 pub extern "C" fn InMemorySigner_get_commitment_seed(this_ptr: &InMemorySigner) -> *const [u8; 32] {
1010         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_seed;
1011         inner_val
1012 }
1013 /// Commitment seed
1014 #[no_mangle]
1015 pub extern "C" fn InMemorySigner_set_commitment_seed(this_ptr: &mut InMemorySigner, mut val: crate::c_types::ThirtyTwoBytes) {
1016         unsafe { &mut *this_ptr.inner }.commitment_seed = val.data;
1017 }
1018 impl Clone for InMemorySigner {
1019         fn clone(&self) -> Self {
1020                 Self {
1021                         inner: if <*mut nativeInMemorySigner>::is_null(self.inner) { std::ptr::null_mut() } else {
1022                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1023                         is_owned: true,
1024                 }
1025         }
1026 }
1027 #[allow(unused)]
1028 /// Used only if an object of this type is returned as a trait impl by a method
1029 pub(crate) extern "C" fn InMemorySigner_clone_void(this_ptr: *const c_void) -> *mut c_void {
1030         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInMemorySigner)).clone() })) as *mut c_void
1031 }
1032 #[no_mangle]
1033 /// Creates a copy of the InMemorySigner
1034 pub extern "C" fn InMemorySigner_clone(orig: &InMemorySigner) -> InMemorySigner {
1035         orig.clone()
1036 }
1037 /// Create a new InMemorySigner
1038 #[must_use]
1039 #[no_mangle]
1040 pub extern "C" fn InMemorySigner_new(mut funding_key: crate::c_types::SecretKey, mut revocation_base_key: crate::c_types::SecretKey, mut payment_key: crate::c_types::SecretKey, mut delayed_payment_base_key: crate::c_types::SecretKey, mut htlc_base_key: crate::c_types::SecretKey, mut commitment_seed: crate::c_types::ThirtyTwoBytes, mut channel_value_satoshis: u64, mut channel_keys_id: crate::c_types::ThirtyTwoBytes) -> crate::lightning::chain::keysinterface::InMemorySigner {
1041         let mut ret = lightning::chain::keysinterface::InMemorySigner::new(secp256k1::SECP256K1, funding_key.into_rust(), revocation_base_key.into_rust(), payment_key.into_rust(), delayed_payment_base_key.into_rust(), htlc_base_key.into_rust(), commitment_seed.data, channel_value_satoshis, channel_keys_id.data);
1042         crate::lightning::chain::keysinterface::InMemorySigner { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1043 }
1044
1045 /// Counterparty pubkeys.
1046 /// Will panic if ready_channel wasn't called.
1047 #[must_use]
1048 #[no_mangle]
1049 pub extern "C" fn InMemorySigner_counterparty_pubkeys(this_arg: &InMemorySigner) -> crate::lightning::ln::chan_utils::ChannelPublicKeys {
1050         let mut ret = unsafe { &*this_arg.inner }.counterparty_pubkeys();
1051         crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1052 }
1053
1054 /// The contest_delay value specified by our counterparty and applied on holder-broadcastable
1055 /// transactions, ie the amount of time that we have to wait to recover our funds if we
1056 /// broadcast a transaction.
1057 /// Will panic if ready_channel wasn't called.
1058 #[must_use]
1059 #[no_mangle]
1060 pub extern "C" fn InMemorySigner_counterparty_selected_contest_delay(this_arg: &InMemorySigner) -> u16 {
1061         let mut ret = unsafe { &*this_arg.inner }.counterparty_selected_contest_delay();
1062         ret
1063 }
1064
1065 /// The contest_delay value specified by us and applied on transactions broadcastable
1066 /// by our counterparty, ie the amount of time that they have to wait to recover their funds
1067 /// if they broadcast a transaction.
1068 /// Will panic if ready_channel wasn't called.
1069 #[must_use]
1070 #[no_mangle]
1071 pub extern "C" fn InMemorySigner_holder_selected_contest_delay(this_arg: &InMemorySigner) -> u16 {
1072         let mut ret = unsafe { &*this_arg.inner }.holder_selected_contest_delay();
1073         ret
1074 }
1075
1076 /// Whether the holder is the initiator
1077 /// Will panic if ready_channel wasn't called.
1078 #[must_use]
1079 #[no_mangle]
1080 pub extern "C" fn InMemorySigner_is_outbound(this_arg: &InMemorySigner) -> bool {
1081         let mut ret = unsafe { &*this_arg.inner }.is_outbound();
1082         ret
1083 }
1084
1085 /// Funding outpoint
1086 /// Will panic if ready_channel wasn't called.
1087 #[must_use]
1088 #[no_mangle]
1089 pub extern "C" fn InMemorySigner_funding_outpoint(this_arg: &InMemorySigner) -> crate::lightning::chain::transaction::OutPoint {
1090         let mut ret = unsafe { &*this_arg.inner }.funding_outpoint();
1091         crate::lightning::chain::transaction::OutPoint { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1092 }
1093
1094 /// Obtain a ChannelTransactionParameters for this channel, to be used when verifying or
1095 /// building transactions.
1096 ///
1097 /// Will panic if ready_channel wasn't called.
1098 #[must_use]
1099 #[no_mangle]
1100 pub extern "C" fn InMemorySigner_get_channel_parameters(this_arg: &InMemorySigner) -> crate::lightning::ln::chan_utils::ChannelTransactionParameters {
1101         let mut ret = unsafe { &*this_arg.inner }.get_channel_parameters();
1102         crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1103 }
1104
1105 /// Sign the single input of spend_tx at index `input_idx` which spends the output
1106 /// described by descriptor, returning the witness stack for the input.
1107 ///
1108 /// Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
1109 /// or is not spending the outpoint described by `descriptor.outpoint`.
1110 #[must_use]
1111 #[no_mangle]
1112 pub extern "C" fn InMemorySigner_sign_counterparty_payment_input(this_arg: &InMemorySigner, mut spend_tx: crate::c_types::Transaction, mut input_idx: usize, descriptor: &crate::lightning::chain::keysinterface::StaticPaymentOutputDescriptor) -> crate::c_types::derived::CResult_CVec_CVec_u8ZZNoneZ {
1113         let mut ret = unsafe { &*this_arg.inner }.sign_counterparty_payment_input(&spend_tx.into_bitcoin(), input_idx, unsafe { &*descriptor.inner }, secp256k1::SECP256K1);
1114         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_ret_0 = Vec::new(); for mut item in o.drain(..) { local_ret_0.push( { let mut local_ret_0_0 = Vec::new(); for mut item in item.drain(..) { local_ret_0_0.push( { item }); }; local_ret_0_0.into() }); }; local_ret_0.into() }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1115         local_ret
1116 }
1117
1118 /// Sign the single input of spend_tx at index `input_idx` which spends the output
1119 /// described by descriptor, returning the witness stack for the input.
1120 ///
1121 /// Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
1122 /// is not spending the outpoint described by `descriptor.outpoint`, or does not have a
1123 /// sequence set to `descriptor.to_self_delay`.
1124 #[must_use]
1125 #[no_mangle]
1126 pub extern "C" fn InMemorySigner_sign_dynamic_p2wsh_input(this_arg: &InMemorySigner, mut spend_tx: crate::c_types::Transaction, mut input_idx: usize, descriptor: &crate::lightning::chain::keysinterface::DelayedPaymentOutputDescriptor) -> crate::c_types::derived::CResult_CVec_CVec_u8ZZNoneZ {
1127         let mut ret = unsafe { &*this_arg.inner }.sign_dynamic_p2wsh_input(&spend_tx.into_bitcoin(), input_idx, unsafe { &*descriptor.inner }, secp256k1::SECP256K1);
1128         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_ret_0 = Vec::new(); for mut item in o.drain(..) { local_ret_0.push( { let mut local_ret_0_0 = Vec::new(); for mut item in item.drain(..) { local_ret_0_0.push( { item }); }; local_ret_0_0.into() }); }; local_ret_0.into() }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1129         local_ret
1130 }
1131
1132 impl From<nativeInMemorySigner> for crate::lightning::chain::keysinterface::BaseSign {
1133         fn from(obj: nativeInMemorySigner) -> Self {
1134                 let mut rust_obj = InMemorySigner { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1135                 let mut ret = InMemorySigner_as_BaseSign(&rust_obj);
1136                 // 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
1137                 rust_obj.inner = std::ptr::null_mut();
1138                 ret.free = Some(InMemorySigner_free_void);
1139                 ret
1140         }
1141 }
1142 /// Constructs a new BaseSign which calls the relevant methods on this_arg.
1143 /// This copies the `inner` pointer in this_arg and thus the returned BaseSign must be freed before this_arg is
1144 #[no_mangle]
1145 pub extern "C" fn InMemorySigner_as_BaseSign(this_arg: &InMemorySigner) -> crate::lightning::chain::keysinterface::BaseSign {
1146         crate::lightning::chain::keysinterface::BaseSign {
1147                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1148                 free: None,
1149                 get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1150                 release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1151
1152                 pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1153                 set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1154                 channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1155                 sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1156                 sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1157                 sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1158                 sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1159                 sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1160                 sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1161                 ready_channel: InMemorySigner_BaseSign_ready_channel,
1162         }
1163 }
1164
1165 #[must_use]
1166 extern "C" fn InMemorySigner_BaseSign_get_per_commitment_point(this_arg: *const c_void, mut idx: u64) -> crate::c_types::PublicKey {
1167         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::get_per_commitment_point(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, idx, secp256k1::SECP256K1);
1168         crate::c_types::PublicKey::from_rust(&ret)
1169 }
1170 #[must_use]
1171 extern "C" fn InMemorySigner_BaseSign_release_commitment_secret(this_arg: *const c_void, mut idx: u64) -> crate::c_types::ThirtyTwoBytes {
1172         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::release_commitment_secret(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, idx);
1173         crate::c_types::ThirtyTwoBytes { data: ret }
1174 }
1175 #[must_use]
1176 extern "C" fn InMemorySigner_BaseSign_pubkeys(this_arg: *const c_void) -> crate::lightning::ln::chan_utils::ChannelPublicKeys {
1177         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::pubkeys(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, );
1178         crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1179 }
1180 extern "C" fn InMemorySigner_BaseSign_set_pubkeys(trait_self_arg: &BaseSign) {
1181         // This is a bit race-y in the general case, but for our specific use-cases today, we're safe
1182         // Specifically, we must ensure that the first time we're called it can never be in parallel
1183         if trait_self_arg.pubkeys.inner.is_null() {
1184                 unsafe { &mut *(trait_self_arg as *const BaseSign  as *mut BaseSign) }.pubkeys = InMemorySigner_BaseSign_pubkeys(trait_self_arg.this_arg);
1185         }
1186 }
1187 #[must_use]
1188 extern "C" fn InMemorySigner_BaseSign_channel_keys_id(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes {
1189         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::channel_keys_id(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, );
1190         crate::c_types::ThirtyTwoBytes { data: ret }
1191 }
1192 #[must_use]
1193 extern "C" fn InMemorySigner_BaseSign_sign_counterparty_commitment(this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::CommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
1194         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_counterparty_commitment(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*commitment_tx.inner }, secp256k1::SECP256K1);
1195         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let (mut orig_ret_0_0, mut orig_ret_0_1) = o; let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.drain(..) { local_orig_ret_0_1.push( { crate::c_types::Signature::from_rust(&item) }); }; let mut local_ret_0 = (crate::c_types::Signature::from_rust(&orig_ret_0_0), local_orig_ret_0_1.into()).into(); local_ret_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1196         local_ret
1197 }
1198 #[must_use]
1199 extern "C" fn InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs(this_arg: *const c_void, commitment_tx: &crate::lightning::ln::chan_utils::HolderCommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
1200         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_holder_commitment_and_htlcs(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*commitment_tx.inner }, secp256k1::SECP256K1);
1201         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let (mut orig_ret_0_0, mut orig_ret_0_1) = o; let mut local_orig_ret_0_1 = Vec::new(); for mut item in orig_ret_0_1.drain(..) { local_orig_ret_0_1.push( { crate::c_types::Signature::from_rust(&item) }); }; let mut local_ret_0 = (crate::c_types::Signature::from_rust(&orig_ret_0_0), local_orig_ret_0_1.into()).into(); local_ret_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1202         local_ret
1203 }
1204 #[must_use]
1205 extern "C" fn InMemorySigner_BaseSign_sign_justice_transaction(this_arg: *const c_void, mut justice_tx: crate::c_types::Transaction, mut input: usize, mut amount: u64, per_commitment_key: *const [u8; 32], htlc: &crate::lightning::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ {
1206         let mut local_htlc = if htlc.inner.is_null() { None } else { Some((* { unsafe { &*htlc.inner } }).clone()) };
1207         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_justice_transaction(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, &justice_tx.into_bitcoin(), input, amount, &::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *per_commitment_key}[..]).unwrap(), &local_htlc, secp256k1::SECP256K1);
1208         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1209         local_ret
1210 }
1211 #[must_use]
1212 extern "C" fn InMemorySigner_BaseSign_sign_counterparty_htlc_transaction(this_arg: *const c_void, mut htlc_tx: crate::c_types::Transaction, mut input: usize, mut amount: u64, mut per_commitment_point: crate::c_types::PublicKey, htlc: &crate::lightning::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ {
1213         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_counterparty_htlc_transaction(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, &htlc_tx.into_bitcoin(), input, amount, &per_commitment_point.into_rust(), unsafe { &*htlc.inner }, secp256k1::SECP256K1);
1214         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1215         local_ret
1216 }
1217 #[must_use]
1218 extern "C" fn InMemorySigner_BaseSign_sign_closing_transaction(this_arg: *const c_void, mut closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ {
1219         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_closing_transaction(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, &closing_tx.into_bitcoin(), secp256k1::SECP256K1);
1220         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1221         local_ret
1222 }
1223 #[must_use]
1224 extern "C" fn InMemorySigner_BaseSign_sign_channel_announcement(this_arg: *const c_void, msg: &crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ {
1225         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_channel_announcement(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*msg.inner }, secp256k1::SECP256K1);
1226         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }).into() };
1227         local_ret
1228 }
1229 extern "C" fn InMemorySigner_BaseSign_ready_channel(this_arg: *mut c_void, channel_parameters: &crate::lightning::ln::chan_utils::ChannelTransactionParameters) {
1230         <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::ready_channel(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*channel_parameters.inner })
1231 }
1232
1233 impl From<nativeInMemorySigner> for crate::lightning::chain::keysinterface::Sign {
1234         fn from(obj: nativeInMemorySigner) -> Self {
1235                 let mut rust_obj = InMemorySigner { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1236                 let mut ret = InMemorySigner_as_Sign(&rust_obj);
1237                 // 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
1238                 rust_obj.inner = std::ptr::null_mut();
1239                 ret.free = Some(InMemorySigner_free_void);
1240                 ret
1241         }
1242 }
1243 /// Constructs a new Sign which calls the relevant methods on this_arg.
1244 /// This copies the `inner` pointer in this_arg and thus the returned Sign must be freed before this_arg is
1245 #[no_mangle]
1246 pub extern "C" fn InMemorySigner_as_Sign(this_arg: &InMemorySigner) -> crate::lightning::chain::keysinterface::Sign {
1247         crate::lightning::chain::keysinterface::Sign {
1248                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1249                 free: None,
1250                 BaseSign: crate::lightning::chain::keysinterface::BaseSign {
1251                         this_arg: unsafe { (*this_arg).inner as *mut c_void },
1252                         free: None,
1253                         get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1254                         release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1255
1256                         pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1257                         set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1258                         channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1259                         sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1260                         sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1261                         sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1262                         sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1263                         sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1264                         sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1265                         ready_channel: InMemorySigner_BaseSign_ready_channel,
1266                 },
1267                 BaseSign_clone: InMemorySigner_BaseSign_clone,
1268                 write: InMemorySigner_write_void,
1269                 clone: Some(InMemorySigner_clone_void),
1270         }
1271 }
1272
1273 extern "C" fn InMemorySigner_BaseSign_clone(orig: &crate::lightning::chain::keysinterface::BaseSign) -> crate::lightning::chain::keysinterface::BaseSign {
1274         crate::lightning::chain::keysinterface::BaseSign {
1275                 this_arg: orig.this_arg,
1276                 free: None,
1277                 get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1278                 release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1279
1280                 pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1281                 set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1282                 channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1283                 sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1284                 sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1285                 sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1286                 sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1287                 sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1288                 sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1289                 ready_channel: InMemorySigner_BaseSign_ready_channel,
1290         }
1291 }
1292
1293 #[no_mangle]
1294 /// Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
1295 pub extern "C" fn InMemorySigner_write(obj: &InMemorySigner) -> crate::c_types::derived::CVec_u8Z {
1296         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
1297 }
1298 #[no_mangle]
1299 pub(crate) extern "C" fn InMemorySigner_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
1300         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInMemorySigner) })
1301 }
1302 #[no_mangle]
1303 /// Read a InMemorySigner from a byte array, created by InMemorySigner_write
1304 pub extern "C" fn InMemorySigner_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InMemorySignerDecodeErrorZ {
1305         let res = crate::c_types::deserialize_obj(ser);
1306         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::chain::keysinterface::InMemorySigner { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
1307         local_res
1308 }
1309
1310 use lightning::chain::keysinterface::KeysManager as nativeKeysManagerImport;
1311 type nativeKeysManager = nativeKeysManagerImport;
1312
1313 /// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
1314 /// and derives keys from that.
1315 ///
1316 /// Your node_id is seed/0'
1317 /// ChannelMonitor closes may use seed/1'
1318 /// Cooperative closes may use seed/2'
1319 /// The two close keys may be needed to claim on-chain funds!
1320 #[must_use]
1321 #[repr(C)]
1322 pub struct KeysManager {
1323         /// A pointer to the opaque Rust object.
1324
1325         /// Nearly everywhere, inner must be non-null, however in places where
1326         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1327         pub inner: *mut nativeKeysManager,
1328         /// Indicates that this is the only struct which contains the same pointer.
1329
1330         /// Rust functions which take ownership of an object provided via an argument require
1331         /// this to be true and invalidate the object pointed to by inner.
1332         pub is_owned: bool,
1333 }
1334
1335 impl Drop for KeysManager {
1336         fn drop(&mut self) {
1337                 if self.is_owned && !<*mut nativeKeysManager>::is_null(self.inner) {
1338                         let _ = unsafe { Box::from_raw(self.inner) };
1339                 }
1340         }
1341 }
1342 /// Frees any resources used by the KeysManager, if is_owned is set and inner is non-NULL.
1343 #[no_mangle]
1344 pub extern "C" fn KeysManager_free(this_obj: KeysManager) { }
1345 #[allow(unused)]
1346 /// Used only if an object of this type is returned as a trait impl by a method
1347 extern "C" fn KeysManager_free_void(this_ptr: *mut c_void) {
1348         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeKeysManager); }
1349 }
1350 #[allow(unused)]
1351 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1352 impl KeysManager {
1353         pub(crate) fn take_inner(mut self) -> *mut nativeKeysManager {
1354                 assert!(self.is_owned);
1355                 let ret = self.inner;
1356                 self.inner = std::ptr::null_mut();
1357                 ret
1358         }
1359 }
1360 /// Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
1361 /// CSRNG is busted) this may panic (but more importantly, you will possibly lose funds).
1362 /// starting_time isn't strictly required to actually be a time, but it must absolutely,
1363 /// without a doubt, be unique to this instance. ie if you start multiple times with the same
1364 /// seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to
1365 /// simply use the current time (with very high precision).
1366 ///
1367 /// The seed MUST be backed up safely prior to use so that the keys can be re-created, however,
1368 /// obviously, starting_time should be unique every time you reload the library - it is only
1369 /// used to generate new ephemeral key data (which will be stored by the individual channel if
1370 /// necessary).
1371 ///
1372 /// Note that the seed is required to recover certain on-chain funds independent of
1373 /// ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any
1374 /// channel, and some on-chain during-closing funds.
1375 ///
1376 /// Note that until the 0.1 release there is no guarantee of backward compatibility between
1377 /// versions. Once the library is more fully supported, the docs will be updated to include a
1378 /// detailed description of the guarantee.
1379 #[must_use]
1380 #[no_mangle]
1381 pub extern "C" fn KeysManager_new(seed: *const [u8; 32], mut starting_time_secs: u64, mut starting_time_nanos: u32) -> KeysManager {
1382         let mut ret = lightning::chain::keysinterface::KeysManager::new(unsafe { &*seed}, starting_time_secs, starting_time_nanos);
1383         KeysManager { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1384 }
1385
1386 /// Derive an old Sign containing per-channel secrets based on a key derivation parameters.
1387 ///
1388 /// Key derivation parameters are accessible through a per-channel secrets
1389 /// Sign::channel_keys_id and is provided inside DynamicOuputP2WSH in case of
1390 /// onchain output detection for which a corresponding delayed_payment_key must be derived.
1391 #[must_use]
1392 #[no_mangle]
1393 pub extern "C" fn KeysManager_derive_channel_keys(this_arg: &KeysManager, mut channel_value_satoshis: u64, params: *const [u8; 32]) -> crate::lightning::chain::keysinterface::InMemorySigner {
1394         let mut ret = unsafe { &*this_arg.inner }.derive_channel_keys(channel_value_satoshis, unsafe { &*params});
1395         crate::lightning::chain::keysinterface::InMemorySigner { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1396 }
1397
1398 /// Creates a Transaction which spends the given descriptors to the given outputs, plus an
1399 /// output to the given change destination (if sufficient change value remains). The
1400 /// transaction will have a feerate, at least, of the given value.
1401 ///
1402 /// Returns `Err(())` if the output value is greater than the input value minus required fee or
1403 /// if a descriptor was duplicated.
1404 ///
1405 /// We do not enforce that outputs meet the dust limit or that any output scripts are standard.
1406 ///
1407 /// May panic if the `SpendableOutputDescriptor`s were not generated by Channels which used
1408 /// this KeysManager or one of the `InMemorySigner` created by this KeysManager.
1409 #[must_use]
1410 #[no_mangle]
1411 pub extern "C" fn KeysManager_spend_spendable_outputs(this_arg: &KeysManager, mut descriptors: crate::c_types::derived::CVec_SpendableOutputDescriptorZ, mut outputs: crate::c_types::derived::CVec_TxOutZ, mut change_destination_script: crate::c_types::derived::CVec_u8Z, mut feerate_sat_per_1000_weight: u32) -> crate::c_types::derived::CResult_TransactionNoneZ {
1412         let mut local_descriptors = Vec::new(); for mut item in descriptors.into_rust().drain(..) { local_descriptors.push( { item.into_native() }); };
1413         let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_rust() }); };
1414         let mut ret = unsafe { &*this_arg.inner }.spend_spendable_outputs(&local_descriptors.iter().collect::<Vec<_>>()[..], local_outputs, ::bitcoin::blockdata::script::Script::from(change_destination_script.into_rust()), feerate_sat_per_1000_weight, secp256k1::SECP256K1);
1415         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( { 0u8 /*e*/ }).into() };
1416         local_ret
1417 }
1418
1419 impl From<nativeKeysManager> for crate::lightning::chain::keysinterface::KeysInterface {
1420         fn from(obj: nativeKeysManager) -> Self {
1421                 let mut rust_obj = KeysManager { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1422                 let mut ret = KeysManager_as_KeysInterface(&rust_obj);
1423                 // 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
1424                 rust_obj.inner = std::ptr::null_mut();
1425                 ret.free = Some(KeysManager_free_void);
1426                 ret
1427         }
1428 }
1429 /// Constructs a new KeysInterface which calls the relevant methods on this_arg.
1430 /// This copies the `inner` pointer in this_arg and thus the returned KeysInterface must be freed before this_arg is
1431 #[no_mangle]
1432 pub extern "C" fn KeysManager_as_KeysInterface(this_arg: &KeysManager) -> crate::lightning::chain::keysinterface::KeysInterface {
1433         crate::lightning::chain::keysinterface::KeysInterface {
1434                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1435                 free: None,
1436                 get_node_secret: KeysManager_KeysInterface_get_node_secret,
1437                 get_destination_script: KeysManager_KeysInterface_get_destination_script,
1438                 get_shutdown_pubkey: KeysManager_KeysInterface_get_shutdown_pubkey,
1439                 get_channel_signer: KeysManager_KeysInterface_get_channel_signer,
1440                 get_secure_random_bytes: KeysManager_KeysInterface_get_secure_random_bytes,
1441                 read_chan_signer: KeysManager_KeysInterface_read_chan_signer,
1442         }
1443 }
1444
1445 #[must_use]
1446 extern "C" fn KeysManager_KeysInterface_get_node_secret(this_arg: *const c_void) -> crate::c_types::SecretKey {
1447         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_node_secret(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1448         crate::c_types::SecretKey::from_rust(ret)
1449 }
1450 #[must_use]
1451 extern "C" fn KeysManager_KeysInterface_get_destination_script(this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z {
1452         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_destination_script(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1453         ret.into_bytes().into()
1454 }
1455 #[must_use]
1456 extern "C" fn KeysManager_KeysInterface_get_shutdown_pubkey(this_arg: *const c_void) -> crate::c_types::PublicKey {
1457         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_shutdown_pubkey(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1458         crate::c_types::PublicKey::from_rust(&ret)
1459 }
1460 #[must_use]
1461 extern "C" fn KeysManager_KeysInterface_get_channel_signer(this_arg: *const c_void, mut _inbound: bool, mut channel_value_satoshis: u64) -> crate::lightning::chain::keysinterface::Sign {
1462         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_channel_signer(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, _inbound, channel_value_satoshis);
1463         ret.into()
1464 }
1465 #[must_use]
1466 extern "C" fn KeysManager_KeysInterface_get_secure_random_bytes(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes {
1467         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_secure_random_bytes(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1468         crate::c_types::ThirtyTwoBytes { data: ret }
1469 }
1470 #[must_use]
1471 extern "C" fn KeysManager_KeysInterface_read_chan_signer(this_arg: *const c_void, mut reader: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SignDecodeErrorZ {
1472         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::read_chan_signer(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, reader.to_slice());
1473         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o.into() }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
1474         local_ret
1475 }
1476