_ 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
 602 use lightning::chain::keysinterface::BaseSign as rustBaseSign;
 603 impl rustBaseSign for BaseSign {
 604         fn get_per_commitment_point(&self, mut idx: u64, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::key::PublicKey {
 605                 let mut ret = (self.get_per_commitment_point)(self.this_arg, idx);
 606                 ret.into_rust()
 607         }
 608         fn release_commitment_secret(&self, mut idx: u64) -> [u8; 32] {
 609                 let mut ret = (self.release_commitment_secret)(self.this_arg, idx);
 610                 ret.data
 611         }
 612         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 613                 if let Some(f) = self.set_pubkeys {
 614                         (f)(&self);
 615                 }
 616                 unsafe { &*self.pubkeys.inner }
 617         }
 618         fn channel_keys_id(&self) -> [u8; 32] {
 619                 let mut ret = (self.channel_keys_id)(self.this_arg);
 620                 ret.data
 621         }
 622         fn sign_counterparty_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 623                 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 });
 624                 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)) })*/ })};
 625                 local_ret
 626         }
 627         fn sign_holder_commitment_and_htlcs(&self, mut commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 628                 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 });
 629                 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)) })*/ })};
 630                 local_ret
 631         }
 632         fn sign_justice_transaction(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::key::SecretKey, mut htlc: &Option<lightning::ln::chan_utils::HTLCOutputInCommitment>, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 633                 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 };
 634                 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);
 635                 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)) })*/ })};
 636                 local_ret
 637         }
 638         fn sign_counterparty_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_point: &bitcoin::secp256k1::key::PublicKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 639                 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 });
 640                 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)) })*/ })};
 641                 local_ret
 642         }
 643         fn sign_closing_transaction(&self, mut closing_tx: &bitcoin::blockdata::transaction::Transaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 644                 let mut ret = (self.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(closing_tx));
 645                 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)) })*/ })};
 646                 local_ret
 647         }
 648         fn sign_channel_announcement(&self, mut msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 649                 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 });
 650                 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)) })*/ })};
 651                 local_ret
 652         }
 653         fn ready_channel(&mut self, mut channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 654                 (self.ready_channel)(self.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { (channel_parameters as *const _) as *mut _ }, is_owned: false })
 655         }
 656 }
 657
 658 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 659 // directly as a Deref trait in higher-level structs:
 660 impl std::ops::Deref for BaseSign {
 661         type Target = Self;
 662         fn deref(&self) -> &Self {
 663                 self
 664         }
 665 }
 666 /// Calls the free function if one is set
 667 #[no_mangle]
 668 pub extern "C" fn BaseSign_free(this_ptr: BaseSign) { }
 669 impl Drop for BaseSign {
 670         fn drop(&mut self) {
 671                 if let Some(f) = self.free {
 672                         f(self.this_arg);
 673                 }
 674         }
 675 }
 676 /// A cloneable signer.
 677 ///
 678 /// Although we require signers to be cloneable, it may be useful for developers to be able to use
 679 /// signers in an un-sized way, for example as `dyn BaseSign`. Therefore we separate the Clone trait,
 680 /// which implies Sized, into this derived trait.
 681 #[repr(C)]
 682 pub struct Sign {
 683         /// An opaque pointer which is passed to your function implementations as an argument.
 684         /// This has no meaning in the LDK, and can be NULL or any other value.
 685         pub this_arg: *mut c_void,
 686         /// Implementation of BaseSign for this object.
 687         pub BaseSign: crate::lightning::chain::keysinterface::BaseSign,
 688         /// Creates a copy of the BaseSign, for a copy of this Sign.
 689         /// Because BaseSign doesn't natively support copying itself, you have to provide a full copy implementation here.
 690         pub BaseSign_clone: extern "C" fn (orig_BaseSign: &BaseSign) -> BaseSign,
 691         /// Serialize the object into a byte array
 692         pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 693         /// Creates a copy of the object pointed to by this_arg, for a copy of this Sign.
 694         /// Note that the ultimate copy of the Sign will have all function pointers the same as the original.
 695         /// May be NULL if no action needs to be taken, the this_arg pointer will be copied into the new Sign.
 696         pub clone: Option<extern "C" fn (this_arg: *const c_void) -> *mut c_void>,
 697         /// Frees any resources associated with this object given its this_arg pointer.
 698         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 699         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 700 }
 701 impl lightning::chain::keysinterface::BaseSign for Sign {
 702         fn get_per_commitment_point(&self, mut idx: u64, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> bitcoin::secp256k1::key::PublicKey {
 703                 let mut ret = (self.BaseSign.get_per_commitment_point)(self.this_arg, idx);
 704                 ret.into_rust()
 705         }
 706         fn release_commitment_secret(&self, mut idx: u64) -> [u8; 32] {
 707                 let mut ret = (self.BaseSign.release_commitment_secret)(self.this_arg, idx);
 708                 ret.data
 709         }
 710         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 711                 if let Some(f) = self.BaseSign.set_pubkeys {
 712                         (f)(&self.BaseSign);
 713                 }
 714                 unsafe { &*self.BaseSign.pubkeys.inner }
 715         }
 716         fn channel_keys_id(&self) -> [u8; 32] {
 717                 let mut ret = (self.BaseSign.channel_keys_id)(self.this_arg);
 718                 ret.data
 719         }
 720         fn sign_counterparty_commitment(&self, mut commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 721                 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 });
 722                 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)) })*/ })};
 723                 local_ret
 724         }
 725         fn sign_holder_commitment_and_htlcs(&self, mut commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 726                 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 });
 727                 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)) })*/ })};
 728                 local_ret
 729         }
 730         fn sign_justice_transaction(&self, mut justice_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_key: &bitcoin::secp256k1::key::SecretKey, mut htlc: &Option<lightning::ln::chan_utils::HTLCOutputInCommitment>, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 731                 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 };
 732                 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);
 733                 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)) })*/ })};
 734                 local_ret
 735         }
 736         fn sign_counterparty_htlc_transaction(&self, mut htlc_tx: &bitcoin::blockdata::transaction::Transaction, mut input: usize, mut amount: u64, mut per_commitment_point: &bitcoin::secp256k1::key::PublicKey, mut htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 737                 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 });
 738                 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)) })*/ })};
 739                 local_ret
 740         }
 741         fn sign_closing_transaction(&self, mut closing_tx: &bitcoin::blockdata::transaction::Transaction, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 742                 let mut ret = (self.BaseSign.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_bitcoin(closing_tx));
 743                 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)) })*/ })};
 744                 local_ret
 745         }
 746         fn sign_channel_announcement(&self, mut msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, mut _secp_ctx: &bitcoin::secp256k1::Secp256k1<bitcoin::secp256k1::All>) -> Result<bitcoin::secp256k1::Signature, ()> {
 747                 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 });
 748                 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)) })*/ })};
 749                 local_ret
 750         }
 751         fn ready_channel(&mut self, mut channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 752                 (self.BaseSign.ready_channel)(self.this_arg, &crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { (channel_parameters as *const _) as *mut _ }, is_owned: false })
 753         }
 754 }
 755 impl lightning::util::ser::Writeable for Sign {
 756         fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 757                 let vec = (self.write)(self.this_arg);
 758                 w.write_all(vec.as_slice())
 759         }
 760 }
 761 #[no_mangle]
 762 /// Creates a copy of a Sign
 763 pub extern "C" fn Sign_clone(orig: &Sign) -> Sign {
 764         Sign {
 765                 this_arg: if let Some(f) = orig.clone { (f)(orig.this_arg) } else { orig.this_arg },
 766                 BaseSign: (orig.BaseSign_clone)(&orig.BaseSign),
 767                 BaseSign_clone: orig.BaseSign_clone,
 768                 write: Clone::clone(&orig.write),
 769                 clone: Clone::clone(&orig.clone),
 770                 free: Clone::clone(&orig.free),
 771         }
 772 }
 773 impl Clone for Sign {
 774         fn clone(&self) -> Self {
 775                 Sign_clone(self)
 776         }
 777 }
 778
 779 use lightning::chain::keysinterface::Sign as rustSign;
 780 impl rustSign for Sign {
 781 }
 782
 783 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 784 // directly as a Deref trait in higher-level structs:
 785 impl std::ops::Deref for Sign {
 786         type Target = Self;
 787         fn deref(&self) -> &Self {
 788                 self
 789         }
 790 }
 791 /// Calls the free function if one is set
 792 #[no_mangle]
 793 pub extern "C" fn Sign_free(this_ptr: Sign) { }
 794 impl Drop for Sign {
 795         fn drop(&mut self) {
 796                 if let Some(f) = self.free {
 797                         f(self.this_arg);
 798                 }
 799         }
 800 }
 801 /// A trait to describe an object which can get user secrets and key material.
 802 #[repr(C)]
 803 pub struct KeysInterface {
 804         /// An opaque pointer which is passed to your function implementations as an argument.
 805         /// This has no meaning in the LDK, and can be NULL or any other value.
 806         pub this_arg: *mut c_void,
 807         /// Get node secret key (aka node_id or network_key).
 808         ///
 809         /// This method must return the same value each time it is called.
 810         #[must_use]
 811         pub get_node_secret: extern "C" fn (this_arg: *const c_void) -> crate::c_types::SecretKey,
 812         /// Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
 813         ///
 814         /// This method should return a different value each time it is called, to avoid linking
 815         /// on-chain funds across channels as controlled to the same user.
 816         #[must_use]
 817         pub get_destination_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 818         /// Get a public key which we will send funds to (in the form of a P2WPKH output) when closing
 819         /// a channel.
 820         ///
 821         /// This method should return a different value each time it is called, to avoid linking
 822         /// on-chain funds across channels as controlled to the same user.
 823         #[must_use]
 824         pub get_shutdown_pubkey: extern "C" fn (this_arg: *const c_void) -> crate::c_types::PublicKey,
 825         /// Get a new set of Sign for per-channel secrets. These MUST be unique even if you
 826         /// restarted with some stale data!
 827         ///
 828         /// This method must return a different value each time it is called.
 829         #[must_use]
 830         pub get_channel_signer: extern "C" fn (this_arg: *const c_void, inbound: bool, channel_value_satoshis: u64) -> crate::lightning::chain::keysinterface::Sign,
 831         /// Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
 832         /// onion packets and for temporary channel IDs. There is no requirement that these be
 833         /// persisted anywhere, though they must be unique across restarts.
 834         ///
 835         /// This method must return a different value each time it is called.
 836         #[must_use]
 837         pub get_secure_random_bytes: extern "C" fn (this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes,
 838         /// Reads a `Signer` for this `KeysInterface` from the given input stream.
 839         /// This is only called during deserialization of other objects which contain
 840         /// `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
 841         /// The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
 842         /// contain no versioning scheme. You may wish to include your own version prefix and ensure
 843         /// you've read all of the provided bytes to ensure no corruption occurred.
 844         #[must_use]
 845         pub read_chan_signer: extern "C" fn (this_arg: *const c_void, reader: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SignDecodeErrorZ,
 846         /// Sign an invoice's preimage (note that this is the preimage of the invoice, not the HTLC's
 847         /// preimage). By parameterizing by the preimage instead of the hash, we allow implementors of
 848         /// this trait to parse the invoice and make sure they're signing what they expect, rather than
 849         /// blindly signing the hash.
 850         #[must_use]
 851         pub sign_invoice: extern "C" fn (this_arg: *const c_void, invoice_preimage: crate::c_types::derived::CVec_u8Z) -> crate::c_types::derived::CResult_RecoverableSignatureNoneZ,
 852         /// Frees any resources associated with this object given its this_arg pointer.
 853         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
 854         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 855 }
 856
 857 use lightning::chain::keysinterface::KeysInterface as rustKeysInterface;
 858 impl rustKeysInterface for KeysInterface {
 859         type Signer = crate::lightning::chain::keysinterface::Sign;
 860         fn get_node_secret(&self) -> bitcoin::secp256k1::key::SecretKey {
 861                 let mut ret = (self.get_node_secret)(self.this_arg);
 862                 ret.into_rust()
 863         }
 864         fn get_destination_script(&self) -> bitcoin::blockdata::script::Script {
 865                 let mut ret = (self.get_destination_script)(self.this_arg);
 866                 ::bitcoin::blockdata::script::Script::from(ret.into_rust())
 867         }
 868         fn get_shutdown_pubkey(&self) -> bitcoin::secp256k1::key::PublicKey {
 869                 let mut ret = (self.get_shutdown_pubkey)(self.this_arg);
 870                 ret.into_rust()
 871         }
 872         fn get_channel_signer(&self, mut inbound: bool, mut channel_value_satoshis: u64) -> crate::lightning::chain::keysinterface::Sign {
 873                 let mut ret = (self.get_channel_signer)(self.this_arg, inbound, channel_value_satoshis);
 874                 ret
 875         }
 876         fn get_secure_random_bytes(&self) -> [u8; 32] {
 877                 let mut ret = (self.get_secure_random_bytes)(self.this_arg);
 878                 ret.data
 879         }
 880         fn read_chan_signer(&self, mut reader: &[u8]) -> Result<crate::lightning::chain::keysinterface::Sign, lightning::ln::msgs::DecodeError> {
 881                 let mut local_reader = crate::c_types::u8slice::from_slice(reader);
 882                 let mut ret = (self.read_chan_signer)(self.this_arg, local_reader);
 883                 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()) } })};
 884                 local_ret
 885         }
 886         fn sign_invoice(&self, mut invoice_preimage: Vec<u8>) -> Result<bitcoin::secp256k1::recovery::RecoverableSignature, ()> {
 887                 let mut local_invoice_preimage = Vec::new(); for mut item in invoice_preimage.drain(..) { local_invoice_preimage.push( { item }); };
 888                 let mut ret = (self.sign_invoice)(self.this_arg, local_invoice_preimage.into());
 889                 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)) })*/ })};
 890                 local_ret
 891         }
 892 }
 893
 894 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 895 // directly as a Deref trait in higher-level structs:
 896 impl std::ops::Deref for KeysInterface {
 897         type Target = Self;
 898         fn deref(&self) -> &Self {
 899                 self
 900         }
 901 }
 902 /// Calls the free function if one is set
 903 #[no_mangle]
 904 pub extern "C" fn KeysInterface_free(this_ptr: KeysInterface) { }
 905 impl Drop for KeysInterface {
 906         fn drop(&mut self) {
 907                 if let Some(f) = self.free {
 908                         f(self.this_arg);
 909                 }
 910         }
 911 }
 912
 913 use lightning::chain::keysinterface::InMemorySigner as nativeInMemorySignerImport;
 914 type nativeInMemorySigner = nativeInMemorySignerImport;
 915
 916 /// A simple implementation of Sign that just keeps the private keys in memory.
 917 ///
 918 /// This implementation performs no policy checks and is insufficient by itself as
 919 /// a secure external signer.
 920 #[must_use]
 921 #[repr(C)]
 922 pub struct InMemorySigner {
 923         /// A pointer to the opaque Rust object.
 924
 925         /// Nearly everywhere, inner must be non-null, however in places where
 926         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 927         pub inner: *mut nativeInMemorySigner,
 928         /// Indicates that this is the only struct which contains the same pointer.
 929
 930         /// Rust functions which take ownership of an object provided via an argument require
 931         /// this to be true and invalidate the object pointed to by inner.
 932         pub is_owned: bool,
 933 }
 934
 935 impl Drop for InMemorySigner {
 936         fn drop(&mut self) {
 937                 if self.is_owned && !<*mut nativeInMemorySigner>::is_null(self.inner) {
 938                         let _ = unsafe { Box::from_raw(self.inner) };
 939                 }
 940         }
 941 }
 942 /// Frees any resources used by the InMemorySigner, if is_owned is set and inner is non-NULL.
 943 #[no_mangle]
 944 pub extern "C" fn InMemorySigner_free(this_obj: InMemorySigner) { }
 945 #[allow(unused)]
 946 /// Used only if an object of this type is returned as a trait impl by a method
 947 extern "C" fn InMemorySigner_free_void(this_ptr: *mut c_void) {
 948         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInMemorySigner); }
 949 }
 950 #[allow(unused)]
 951 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 952 impl InMemorySigner {
 953         pub(crate) fn take_inner(mut self) -> *mut nativeInMemorySigner {
 954                 assert!(self.is_owned);
 955                 let ret = self.inner;
 956                 self.inner = std::ptr::null_mut();
 957                 ret
 958         }
 959 }
 960 /// Private key of anchor tx
 961 #[no_mangle]
 962 pub extern "C" fn InMemorySigner_get_funding_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 963         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_key;
 964         inner_val.as_ref()
 965 }
 966 /// Private key of anchor tx
 967 #[no_mangle]
 968 pub extern "C" fn InMemorySigner_set_funding_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 969         unsafe { &mut *this_ptr.inner }.funding_key = val.into_rust();
 970 }
 971 /// Holder secret key for blinded revocation pubkey
 972 #[no_mangle]
 973 pub extern "C" fn InMemorySigner_get_revocation_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 974         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_base_key;
 975         inner_val.as_ref()
 976 }
 977 /// Holder secret key for blinded revocation pubkey
 978 #[no_mangle]
 979 pub extern "C" fn InMemorySigner_set_revocation_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 980         unsafe { &mut *this_ptr.inner }.revocation_base_key = val.into_rust();
 981 }
 982 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 983 #[no_mangle]
 984 pub extern "C" fn InMemorySigner_get_payment_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 985         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_key;
 986         inner_val.as_ref()
 987 }
 988 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 989 #[no_mangle]
 990 pub extern "C" fn InMemorySigner_set_payment_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
 991         unsafe { &mut *this_ptr.inner }.payment_key = val.into_rust();
 992 }
 993 /// Holder secret key used in HTLC tx
 994 #[no_mangle]
 995 pub extern "C" fn InMemorySigner_get_delayed_payment_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
 996         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_base_key;
 997         inner_val.as_ref()
 998 }
 999 /// Holder secret key used in HTLC tx
1000 #[no_mangle]
1001 pub extern "C" fn InMemorySigner_set_delayed_payment_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
1002         unsafe { &mut *this_ptr.inner }.delayed_payment_base_key = val.into_rust();
1003 }
1004 /// Holder htlc secret key used in commitment tx htlc outputs
1005 #[no_mangle]
1006 pub extern "C" fn InMemorySigner_get_htlc_base_key(this_ptr: &InMemorySigner) -> *const [u8; 32] {
1007         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_base_key;
1008         inner_val.as_ref()
1009 }
1010 /// Holder htlc secret key used in commitment tx htlc outputs
1011 #[no_mangle]
1012 pub extern "C" fn InMemorySigner_set_htlc_base_key(this_ptr: &mut InMemorySigner, mut val: crate::c_types::SecretKey) {
1013         unsafe { &mut *this_ptr.inner }.htlc_base_key = val.into_rust();
1014 }
1015 /// Commitment seed
1016 #[no_mangle]
1017 pub extern "C" fn InMemorySigner_get_commitment_seed(this_ptr: &InMemorySigner) -> *const [u8; 32] {
1018         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_seed;
1019         inner_val
1020 }
1021 /// Commitment seed
1022 #[no_mangle]
1023 pub extern "C" fn InMemorySigner_set_commitment_seed(this_ptr: &mut InMemorySigner, mut val: crate::c_types::ThirtyTwoBytes) {
1024         unsafe { &mut *this_ptr.inner }.commitment_seed = val.data;
1025 }
1026 impl Clone for InMemorySigner {
1027         fn clone(&self) -> Self {
1028                 Self {
1029                         inner: if <*mut nativeInMemorySigner>::is_null(self.inner) { std::ptr::null_mut() } else {
1030                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1031                         is_owned: true,
1032                 }
1033         }
1034 }
1035 #[allow(unused)]
1036 /// Used only if an object of this type is returned as a trait impl by a method
1037 pub(crate) extern "C" fn InMemorySigner_clone_void(this_ptr: *const c_void) -> *mut c_void {
1038         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInMemorySigner)).clone() })) as *mut c_void
1039 }
1040 #[no_mangle]
1041 /// Creates a copy of the InMemorySigner
1042 pub extern "C" fn InMemorySigner_clone(orig: &InMemorySigner) -> InMemorySigner {
1043         orig.clone()
1044 }
1045 /// Create a new InMemorySigner
1046 #[must_use]
1047 #[no_mangle]
1048 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 {
1049         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);
1050         crate::lightning::chain::keysinterface::InMemorySigner { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1051 }
1052
1053 /// Counterparty pubkeys.
1054 /// Will panic if ready_channel wasn't called.
1055 #[must_use]
1056 #[no_mangle]
1057 pub extern "C" fn InMemorySigner_counterparty_pubkeys(this_arg: &InMemorySigner) -> crate::lightning::ln::chan_utils::ChannelPublicKeys {
1058         let mut ret = unsafe { &*this_arg.inner }.counterparty_pubkeys();
1059         crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1060 }
1061
1062 /// The contest_delay value specified by our counterparty and applied on holder-broadcastable
1063 /// transactions, ie the amount of time that we have to wait to recover our funds if we
1064 /// broadcast a transaction.
1065 /// Will panic if ready_channel wasn't called.
1066 #[must_use]
1067 #[no_mangle]
1068 pub extern "C" fn InMemorySigner_counterparty_selected_contest_delay(this_arg: &InMemorySigner) -> u16 {
1069         let mut ret = unsafe { &*this_arg.inner }.counterparty_selected_contest_delay();
1070         ret
1071 }
1072
1073 /// The contest_delay value specified by us and applied on transactions broadcastable
1074 /// by our counterparty, ie the amount of time that they have to wait to recover their funds
1075 /// if they broadcast a transaction.
1076 /// Will panic if ready_channel wasn't called.
1077 #[must_use]
1078 #[no_mangle]
1079 pub extern "C" fn InMemorySigner_holder_selected_contest_delay(this_arg: &InMemorySigner) -> u16 {
1080         let mut ret = unsafe { &*this_arg.inner }.holder_selected_contest_delay();
1081         ret
1082 }
1083
1084 /// Whether the holder is the initiator
1085 /// Will panic if ready_channel wasn't called.
1086 #[must_use]
1087 #[no_mangle]
1088 pub extern "C" fn InMemorySigner_is_outbound(this_arg: &InMemorySigner) -> bool {
1089         let mut ret = unsafe { &*this_arg.inner }.is_outbound();
1090         ret
1091 }
1092
1093 /// Funding outpoint
1094 /// Will panic if ready_channel wasn't called.
1095 #[must_use]
1096 #[no_mangle]
1097 pub extern "C" fn InMemorySigner_funding_outpoint(this_arg: &InMemorySigner) -> crate::lightning::chain::transaction::OutPoint {
1098         let mut ret = unsafe { &*this_arg.inner }.funding_outpoint();
1099         crate::lightning::chain::transaction::OutPoint { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1100 }
1101
1102 /// Obtain a ChannelTransactionParameters for this channel, to be used when verifying or
1103 /// building transactions.
1104 ///
1105 /// Will panic if ready_channel wasn't called.
1106 #[must_use]
1107 #[no_mangle]
1108 pub extern "C" fn InMemorySigner_get_channel_parameters(this_arg: &InMemorySigner) -> crate::lightning::ln::chan_utils::ChannelTransactionParameters {
1109         let mut ret = unsafe { &*this_arg.inner }.get_channel_parameters();
1110         crate::lightning::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1111 }
1112
1113 /// Sign the single input of spend_tx at index `input_idx` which spends the output
1114 /// described by descriptor, returning the witness stack for the input.
1115 ///
1116 /// Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
1117 /// or is not spending the outpoint described by `descriptor.outpoint`.
1118 #[must_use]
1119 #[no_mangle]
1120 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 {
1121         let mut ret = unsafe { &*this_arg.inner }.sign_counterparty_payment_input(&spend_tx.into_bitcoin(), input_idx, unsafe { &*descriptor.inner }, secp256k1::SECP256K1);
1122         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( { () /*e*/ }).into() };
1123         local_ret
1124 }
1125
1126 /// Sign the single input of spend_tx at index `input_idx` which spends the output
1127 /// described by descriptor, returning the witness stack for the input.
1128 ///
1129 /// Returns an Err if the input at input_idx does not exist, has a non-empty script_sig,
1130 /// is not spending the outpoint described by `descriptor.outpoint`, or does not have a
1131 /// sequence set to `descriptor.to_self_delay`.
1132 #[must_use]
1133 #[no_mangle]
1134 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 {
1135         let mut ret = unsafe { &*this_arg.inner }.sign_dynamic_p2wsh_input(&spend_tx.into_bitcoin(), input_idx, unsafe { &*descriptor.inner }, secp256k1::SECP256K1);
1136         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( { () /*e*/ }).into() };
1137         local_ret
1138 }
1139
1140 impl From<nativeInMemorySigner> for crate::lightning::chain::keysinterface::BaseSign {
1141         fn from(obj: nativeInMemorySigner) -> Self {
1142                 let mut rust_obj = InMemorySigner { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1143                 let mut ret = InMemorySigner_as_BaseSign(&rust_obj);
1144                 // 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
1145                 rust_obj.inner = std::ptr::null_mut();
1146                 ret.free = Some(InMemorySigner_free_void);
1147                 ret
1148         }
1149 }
1150 /// Constructs a new BaseSign which calls the relevant methods on this_arg.
1151 /// This copies the `inner` pointer in this_arg and thus the returned BaseSign must be freed before this_arg is
1152 #[no_mangle]
1153 pub extern "C" fn InMemorySigner_as_BaseSign(this_arg: &InMemorySigner) -> crate::lightning::chain::keysinterface::BaseSign {
1154         crate::lightning::chain::keysinterface::BaseSign {
1155                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1156                 free: None,
1157                 get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1158                 release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1159
1160                 pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1161                 set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1162                 channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1163                 sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1164                 sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1165                 sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1166                 sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1167                 sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1168                 sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1169                 ready_channel: InMemorySigner_BaseSign_ready_channel,
1170         }
1171 }
1172
1173 #[must_use]
1174 extern "C" fn InMemorySigner_BaseSign_get_per_commitment_point(this_arg: *const c_void, mut idx: u64) -> crate::c_types::PublicKey {
1175         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::get_per_commitment_point(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, idx, secp256k1::SECP256K1);
1176         crate::c_types::PublicKey::from_rust(&ret)
1177 }
1178 #[must_use]
1179 extern "C" fn InMemorySigner_BaseSign_release_commitment_secret(this_arg: *const c_void, mut idx: u64) -> crate::c_types::ThirtyTwoBytes {
1180         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::release_commitment_secret(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, idx);
1181         crate::c_types::ThirtyTwoBytes { data: ret }
1182 }
1183 #[must_use]
1184 extern "C" fn InMemorySigner_BaseSign_pubkeys(this_arg: *const c_void) -> crate::lightning::ln::chan_utils::ChannelPublicKeys {
1185         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::pubkeys(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, );
1186         crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
1187 }
1188 extern "C" fn InMemorySigner_BaseSign_set_pubkeys(trait_self_arg: &BaseSign) {
1189         // This is a bit race-y in the general case, but for our specific use-cases today, we're safe
1190         // Specifically, we must ensure that the first time we're called it can never be in parallel
1191         if trait_self_arg.pubkeys.inner.is_null() {
1192                 unsafe { &mut *(trait_self_arg as *const BaseSign  as *mut BaseSign) }.pubkeys = InMemorySigner_BaseSign_pubkeys(trait_self_arg.this_arg);
1193         }
1194 }
1195 #[must_use]
1196 extern "C" fn InMemorySigner_BaseSign_channel_keys_id(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes {
1197         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::channel_keys_id(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, );
1198         crate::c_types::ThirtyTwoBytes { data: ret }
1199 }
1200 #[must_use]
1201 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 {
1202         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);
1203         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( { () /*e*/ }).into() };
1204         local_ret
1205 }
1206 #[must_use]
1207 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 {
1208         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);
1209         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( { () /*e*/ }).into() };
1210         local_ret
1211 }
1212 #[must_use]
1213 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 {
1214         let mut local_htlc = if htlc.inner.is_null() { None } else { Some((* { unsafe { &*htlc.inner } }).clone()) };
1215         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);
1216         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( { () /*e*/ }).into() };
1217         local_ret
1218 }
1219 #[must_use]
1220 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 {
1221         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);
1222         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( { () /*e*/ }).into() };
1223         local_ret
1224 }
1225 #[must_use]
1226 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 {
1227         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);
1228         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( { () /*e*/ }).into() };
1229         local_ret
1230 }
1231 #[must_use]
1232 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 {
1233         let mut ret = <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::sign_channel_announcement(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*msg.inner }, secp256k1::SECP256K1);
1234         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( { () /*e*/ }).into() };
1235         local_ret
1236 }
1237 extern "C" fn InMemorySigner_BaseSign_ready_channel(this_arg: *mut c_void, channel_parameters: &crate::lightning::ln::chan_utils::ChannelTransactionParameters) {
1238         <nativeInMemorySigner as lightning::chain::keysinterface::BaseSign<>>::ready_channel(unsafe { &mut *(this_arg as *mut nativeInMemorySigner) }, unsafe { &*channel_parameters.inner })
1239 }
1240
1241 impl From<nativeInMemorySigner> for crate::lightning::chain::keysinterface::Sign {
1242         fn from(obj: nativeInMemorySigner) -> Self {
1243                 let mut rust_obj = InMemorySigner { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1244                 let mut ret = InMemorySigner_as_Sign(&rust_obj);
1245                 // 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
1246                 rust_obj.inner = std::ptr::null_mut();
1247                 ret.free = Some(InMemorySigner_free_void);
1248                 ret
1249         }
1250 }
1251 /// Constructs a new Sign which calls the relevant methods on this_arg.
1252 /// This copies the `inner` pointer in this_arg and thus the returned Sign must be freed before this_arg is
1253 #[no_mangle]
1254 pub extern "C" fn InMemorySigner_as_Sign(this_arg: &InMemorySigner) -> crate::lightning::chain::keysinterface::Sign {
1255         crate::lightning::chain::keysinterface::Sign {
1256                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1257                 free: None,
1258                 BaseSign: crate::lightning::chain::keysinterface::BaseSign {
1259                         this_arg: unsafe { (*this_arg).inner as *mut c_void },
1260                         free: None,
1261                         get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1262                         release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1263
1264                         pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1265                         set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1266                         channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1267                         sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1268                         sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1269                         sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1270                         sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1271                         sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1272                         sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1273                         ready_channel: InMemorySigner_BaseSign_ready_channel,
1274                 },
1275                 BaseSign_clone: InMemorySigner_BaseSign_clone,
1276                 write: InMemorySigner_write_void,
1277                 clone: Some(InMemorySigner_clone_void),
1278         }
1279 }
1280
1281 extern "C" fn InMemorySigner_BaseSign_clone(orig: &crate::lightning::chain::keysinterface::BaseSign) -> crate::lightning::chain::keysinterface::BaseSign {
1282         crate::lightning::chain::keysinterface::BaseSign {
1283                 this_arg: orig.this_arg,
1284                 free: None,
1285                 get_per_commitment_point: InMemorySigner_BaseSign_get_per_commitment_point,
1286                 release_commitment_secret: InMemorySigner_BaseSign_release_commitment_secret,
1287
1288                 pubkeys: crate::lightning::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
1289                 set_pubkeys: Some(InMemorySigner_BaseSign_set_pubkeys),
1290                 channel_keys_id: InMemorySigner_BaseSign_channel_keys_id,
1291                 sign_counterparty_commitment: InMemorySigner_BaseSign_sign_counterparty_commitment,
1292                 sign_holder_commitment_and_htlcs: InMemorySigner_BaseSign_sign_holder_commitment_and_htlcs,
1293                 sign_justice_transaction: InMemorySigner_BaseSign_sign_justice_transaction,
1294                 sign_counterparty_htlc_transaction: InMemorySigner_BaseSign_sign_counterparty_htlc_transaction,
1295                 sign_closing_transaction: InMemorySigner_BaseSign_sign_closing_transaction,
1296                 sign_channel_announcement: InMemorySigner_BaseSign_sign_channel_announcement,
1297                 ready_channel: InMemorySigner_BaseSign_ready_channel,
1298         }
1299 }
1300
1301 #[no_mangle]
1302 /// Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
1303 pub extern "C" fn InMemorySigner_write(obj: &InMemorySigner) -> crate::c_types::derived::CVec_u8Z {
1304         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
1305 }
1306 #[no_mangle]
1307 pub(crate) extern "C" fn InMemorySigner_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
1308         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInMemorySigner) })
1309 }
1310 #[no_mangle]
1311 /// Read a InMemorySigner from a byte array, created by InMemorySigner_write
1312 pub extern "C" fn InMemorySigner_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InMemorySignerDecodeErrorZ {
1313         let res = crate::c_types::deserialize_obj(ser);
1314         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() };
1315         local_res
1316 }
1317
1318 use lightning::chain::keysinterface::KeysManager as nativeKeysManagerImport;
1319 type nativeKeysManager = nativeKeysManagerImport;
1320
1321 /// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
1322 /// and derives keys from that.
1323 ///
1324 /// Your node_id is seed/0'
1325 /// ChannelMonitor closes may use seed/1'
1326 /// Cooperative closes may use seed/2'
1327 /// The two close keys may be needed to claim on-chain funds!
1328 #[must_use]
1329 #[repr(C)]
1330 pub struct KeysManager {
1331         /// A pointer to the opaque Rust object.
1332
1333         /// Nearly everywhere, inner must be non-null, however in places where
1334         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1335         pub inner: *mut nativeKeysManager,
1336         /// Indicates that this is the only struct which contains the same pointer.
1337
1338         /// Rust functions which take ownership of an object provided via an argument require
1339         /// this to be true and invalidate the object pointed to by inner.
1340         pub is_owned: bool,
1341 }
1342
1343 impl Drop for KeysManager {
1344         fn drop(&mut self) {
1345                 if self.is_owned && !<*mut nativeKeysManager>::is_null(self.inner) {
1346                         let _ = unsafe { Box::from_raw(self.inner) };
1347                 }
1348         }
1349 }
1350 /// Frees any resources used by the KeysManager, if is_owned is set and inner is non-NULL.
1351 #[no_mangle]
1352 pub extern "C" fn KeysManager_free(this_obj: KeysManager) { }
1353 #[allow(unused)]
1354 /// Used only if an object of this type is returned as a trait impl by a method
1355 extern "C" fn KeysManager_free_void(this_ptr: *mut c_void) {
1356         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeKeysManager); }
1357 }
1358 #[allow(unused)]
1359 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1360 impl KeysManager {
1361         pub(crate) fn take_inner(mut self) -> *mut nativeKeysManager {
1362                 assert!(self.is_owned);
1363                 let ret = self.inner;
1364                 self.inner = std::ptr::null_mut();
1365                 ret
1366         }
1367 }
1368 /// Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
1369 /// CSRNG is busted) this may panic (but more importantly, you will possibly lose funds).
1370 /// starting_time isn't strictly required to actually be a time, but it must absolutely,
1371 /// without a doubt, be unique to this instance. ie if you start multiple times with the same
1372 /// seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to
1373 /// simply use the current time (with very high precision).
1374 ///
1375 /// The seed MUST be backed up safely prior to use so that the keys can be re-created, however,
1376 /// obviously, starting_time should be unique every time you reload the library - it is only
1377 /// used to generate new ephemeral key data (which will be stored by the individual channel if
1378 /// necessary).
1379 ///
1380 /// Note that the seed is required to recover certain on-chain funds independent of
1381 /// ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any
1382 /// channel, and some on-chain during-closing funds.
1383 ///
1384 /// Note that until the 0.1 release there is no guarantee of backward compatibility between
1385 /// versions. Once the library is more fully supported, the docs will be updated to include a
1386 /// detailed description of the guarantee.
1387 #[must_use]
1388 #[no_mangle]
1389 pub extern "C" fn KeysManager_new(seed: *const [u8; 32], mut starting_time_secs: u64, mut starting_time_nanos: u32) -> KeysManager {
1390         let mut ret = lightning::chain::keysinterface::KeysManager::new(unsafe { &*seed}, starting_time_secs, starting_time_nanos);
1391         KeysManager { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1392 }
1393
1394 /// Derive an old Sign containing per-channel secrets based on a key derivation parameters.
1395 ///
1396 /// Key derivation parameters are accessible through a per-channel secrets
1397 /// Sign::channel_keys_id and is provided inside DynamicOuputP2WSH in case of
1398 /// onchain output detection for which a corresponding delayed_payment_key must be derived.
1399 #[must_use]
1400 #[no_mangle]
1401 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 {
1402         let mut ret = unsafe { &*this_arg.inner }.derive_channel_keys(channel_value_satoshis, unsafe { &*params});
1403         crate::lightning::chain::keysinterface::InMemorySigner { inner: Box::into_raw(Box::new(ret)), is_owned: true }
1404 }
1405
1406 /// Creates a Transaction which spends the given descriptors to the given outputs, plus an
1407 /// output to the given change destination (if sufficient change value remains). The
1408 /// transaction will have a feerate, at least, of the given value.
1409 ///
1410 /// Returns `Err(())` if the output value is greater than the input value minus required fee or
1411 /// if a descriptor was duplicated.
1412 ///
1413 /// We do not enforce that outputs meet the dust limit or that any output scripts are standard.
1414 ///
1415 /// May panic if the `SpendableOutputDescriptor`s were not generated by Channels which used
1416 /// this KeysManager or one of the `InMemorySigner` created by this KeysManager.
1417 #[must_use]
1418 #[no_mangle]
1419 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 {
1420         let mut local_descriptors = Vec::new(); for mut item in descriptors.into_rust().drain(..) { local_descriptors.push( { item.into_native() }); };
1421         let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_rust() }); };
1422         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);
1423         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Transaction::from_bitcoin(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { () /*e*/ }).into() };
1424         local_ret
1425 }
1426
1427 impl From<nativeKeysManager> for crate::lightning::chain::keysinterface::KeysInterface {
1428         fn from(obj: nativeKeysManager) -> Self {
1429                 let mut rust_obj = KeysManager { inner: Box::into_raw(Box::new(obj)), is_owned: true };
1430                 let mut ret = KeysManager_as_KeysInterface(&rust_obj);
1431                 // 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
1432                 rust_obj.inner = std::ptr::null_mut();
1433                 ret.free = Some(KeysManager_free_void);
1434                 ret
1435         }
1436 }
1437 /// Constructs a new KeysInterface which calls the relevant methods on this_arg.
1438 /// This copies the `inner` pointer in this_arg and thus the returned KeysInterface must be freed before this_arg is
1439 #[no_mangle]
1440 pub extern "C" fn KeysManager_as_KeysInterface(this_arg: &KeysManager) -> crate::lightning::chain::keysinterface::KeysInterface {
1441         crate::lightning::chain::keysinterface::KeysInterface {
1442                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
1443                 free: None,
1444                 get_node_secret: KeysManager_KeysInterface_get_node_secret,
1445                 get_destination_script: KeysManager_KeysInterface_get_destination_script,
1446                 get_shutdown_pubkey: KeysManager_KeysInterface_get_shutdown_pubkey,
1447                 get_channel_signer: KeysManager_KeysInterface_get_channel_signer,
1448                 get_secure_random_bytes: KeysManager_KeysInterface_get_secure_random_bytes,
1449                 read_chan_signer: KeysManager_KeysInterface_read_chan_signer,
1450                 sign_invoice: KeysManager_KeysInterface_sign_invoice,
1451         }
1452 }
1453
1454 #[must_use]
1455 extern "C" fn KeysManager_KeysInterface_get_node_secret(this_arg: *const c_void) -> crate::c_types::SecretKey {
1456         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_node_secret(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1457         crate::c_types::SecretKey::from_rust(ret)
1458 }
1459 #[must_use]
1460 extern "C" fn KeysManager_KeysInterface_get_destination_script(this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z {
1461         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_destination_script(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1462         ret.into_bytes().into()
1463 }
1464 #[must_use]
1465 extern "C" fn KeysManager_KeysInterface_get_shutdown_pubkey(this_arg: *const c_void) -> crate::c_types::PublicKey {
1466         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_shutdown_pubkey(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1467         crate::c_types::PublicKey::from_rust(&ret)
1468 }
1469 #[must_use]
1470 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 {
1471         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_channel_signer(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, _inbound, channel_value_satoshis);
1472         ret.into()
1473 }
1474 #[must_use]
1475 extern "C" fn KeysManager_KeysInterface_get_secure_random_bytes(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes {
1476         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::get_secure_random_bytes(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, );
1477         crate::c_types::ThirtyTwoBytes { data: ret }
1478 }
1479 #[must_use]
1480 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 {
1481         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::read_chan_signer(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, reader.to_slice());
1482         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() };
1483         local_ret
1484 }
1485 #[must_use]
1486 extern "C" fn KeysManager_KeysInterface_sign_invoice(this_arg: *const c_void, mut invoice_preimage: crate::c_types::derived::CVec_u8Z) -> crate::c_types::derived::CResult_RecoverableSignatureNoneZ {
1487         let mut local_invoice_preimage = Vec::new(); for mut item in invoice_preimage.into_rust().drain(..) { local_invoice_preimage.push( { item }); };
1488         let mut ret = <nativeKeysManager as lightning::chain::keysinterface::KeysInterface<>>::sign_invoice(unsafe { &mut *(this_arg as *mut nativeKeysManager) }, local_invoice_preimage);
1489         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::RecoverableSignature::from_rust(&o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { () /*e*/ }).into() };
1490         local_ret
1491 }
1492