_ Git - rust-lightning/blob - lightning-c-bindings/src/chain/keysinterface.rs

   1 //! keysinterface provides keys into rust-lightning and defines some useful enums which describe
   2 //! spendable on-chain outputs which the user owns and is responsible for using just as any other
   3 //! on-chain output which is theirs.
   4
   5 use std::ffi::c_void;
   6 use bitcoin::hashes::Hash;
   7 use crate::c_types::*;
   8
   9 /// When on-chain outputs are created by rust-lightning (which our counterparty is not able to
  10 /// claim at any point in the future) an event is generated which you must track and be able to
  11 /// spend on-chain. The information needed to do this is provided in this enum, including the
  12 /// outpoint describing which txid and output index is available, the full output which exists at
  13 /// that txid/index, and any keys or other information required to sign.
  14 #[must_use]
  15 #[derive(Clone)]
  16 #[repr(C)]
  17 pub enum SpendableOutputDescriptor {
  18         /// An output to a script which was provided via KeysInterface, thus you should already know
  19         /// how to spend it. No keys are provided as rust-lightning was never given any keys - only the
  20         /// script_pubkey as it appears in the output.
  21         /// These may include outputs from a transaction punishing our counterparty or claiming an HTLC
  22         /// on-chain using the payment preimage or after it has timed out.
  23         StaticOutput {
  24                 outpoint: crate::chain::transaction::OutPoint,
  25                 output: crate::c_types::TxOut,
  26         },
  27         /// An output to a P2WSH script which can be spent with a single signature after a CSV delay.
  28         ///
  29         /// The witness in the spending input should be:
  30         /// <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
  31         ///
  32         /// Note that the nSequence field in the spending input must be set to to_self_delay
  33         /// (which means the transaction is not broadcastable until at least to_self_delay
  34         /// blocks after the outpoint confirms).
  35         ///
  36         /// These are generally the result of a \"revocable\" output to us, spendable only by us unless
  37         /// it is an output from an old state which we broadcast (which should never happen).
  38         ///
  39         /// To derive the delayed_payment key which is used to sign for this input, you must pass the
  40         /// holder delayed_payment_base_key (ie the private key which corresponds to the pubkey in
  41         /// ChannelKeys::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
  42         /// chan_utils::derive_private_key. The public key can be generated without the secret key
  43         /// using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
  44         /// ChannelKeys::pubkeys().
  45         ///
  46         /// To derive the revocation_pubkey provided here (which is used in the witness
  47         /// script generation), you must pass the counterparty revocation_basepoint (which appears in the
  48         /// call to ChannelKeys::ready_channel) and the provided per_commitment point
  49         /// to chan_utils::derive_public_revocation_key.
  50         ///
  51         /// The witness script which is hashed and included in the output script_pubkey may be
  52         /// regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
  53         /// (derived as above), and the to_self_delay contained here to
  54         /// chan_utils::get_revokeable_redeemscript.
  55         DynamicOutputP2WSH {
  56                 outpoint: crate::chain::transaction::OutPoint,
  57                 per_commitment_point: crate::c_types::PublicKey,
  58                 to_self_delay: u16,
  59                 output: crate::c_types::TxOut,
  60                 key_derivation_params: crate::c_types::derived::C2Tuple_u64u64Z,
  61                 revocation_pubkey: crate::c_types::PublicKey,
  62         },
  63         /// An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
  64         /// corresponds to the public key in ChannelKeys::pubkeys().payment_point).
  65         /// The witness in the spending input, is, thus, simply:
  66         /// <BIP 143 signature> <payment key>
  67         ///
  68         /// These are generally the result of our counterparty having broadcast the current state,
  69         /// allowing us to claim the non-HTLC-encumbered outputs immediately.
  70         StaticOutputCounterpartyPayment {
  71                 outpoint: crate::chain::transaction::OutPoint,
  72                 output: crate::c_types::TxOut,
  73                 key_derivation_params: crate::c_types::derived::C2Tuple_u64u64Z,
  74         },
  75 }
  76 use lightning::chain::keysinterface::SpendableOutputDescriptor as nativeSpendableOutputDescriptor;
  77 impl SpendableOutputDescriptor {
  78         #[allow(unused)]
  79         pub(crate) fn to_native(&self) -> nativeSpendableOutputDescriptor {
  80                 match self {
  81                         SpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => {
  82                                 let mut outpoint_nonref = (*outpoint).clone();
  83                                 let mut output_nonref = (*output).clone();
  84                                 nativeSpendableOutputDescriptor::StaticOutput {
  85                                         outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_inner()) },
  86                                         output: output_nonref.into_rust(),
  87                                 }
  88                         },
  89                         SpendableOutputDescriptor::DynamicOutputP2WSH {ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref revocation_pubkey, } => {
  90                                 let mut outpoint_nonref = (*outpoint).clone();
  91                                 let mut per_commitment_point_nonref = (*per_commitment_point).clone();
  92                                 let mut to_self_delay_nonref = (*to_self_delay).clone();
  93                                 let mut output_nonref = (*output).clone();
  94                                 let mut key_derivation_params_nonref = (*key_derivation_params).clone();
  95                                 let (mut orig_key_derivation_params_nonref_0, mut orig_key_derivation_params_nonref_1) = key_derivation_params_nonref.to_rust(); let mut local_key_derivation_params_nonref = (orig_key_derivation_params_nonref_0, orig_key_derivation_params_nonref_1);
  96                                 let mut revocation_pubkey_nonref = (*revocation_pubkey).clone();
  97                                 nativeSpendableOutputDescriptor::DynamicOutputP2WSH {
  98                                         outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_inner()) },
  99                                         per_commitment_point: per_commitment_point_nonref.into_rust(),
 100                                         to_self_delay: to_self_delay_nonref,
 101                                         output: output_nonref.into_rust(),
 102                                         key_derivation_params: local_key_derivation_params_nonref,
 103                                         revocation_pubkey: revocation_pubkey_nonref.into_rust(),
 104                                 }
 105                         },
 106                         SpendableOutputDescriptor::StaticOutputCounterpartyPayment {ref outpoint, ref output, ref key_derivation_params, } => {
 107                                 let mut outpoint_nonref = (*outpoint).clone();
 108                                 let mut output_nonref = (*output).clone();
 109                                 let mut key_derivation_params_nonref = (*key_derivation_params).clone();
 110                                 let (mut orig_key_derivation_params_nonref_0, mut orig_key_derivation_params_nonref_1) = key_derivation_params_nonref.to_rust(); let mut local_key_derivation_params_nonref = (orig_key_derivation_params_nonref_0, orig_key_derivation_params_nonref_1);
 111                                 nativeSpendableOutputDescriptor::StaticOutputCounterpartyPayment {
 112                                         outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_inner()) },
 113                                         output: output_nonref.into_rust(),
 114                                         key_derivation_params: local_key_derivation_params_nonref,
 115                                 }
 116                         },
 117                 }
 118         }
 119         #[allow(unused)]
 120         pub(crate) fn into_native(self) -> nativeSpendableOutputDescriptor {
 121                 match self {
 122                         SpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => {
 123                                 nativeSpendableOutputDescriptor::StaticOutput {
 124                                         outpoint: *unsafe { Box::from_raw(outpoint.take_inner()) },
 125                                         output: output.into_rust(),
 126                                 }
 127                         },
 128                         SpendableOutputDescriptor::DynamicOutputP2WSH {mut outpoint, mut per_commitment_point, mut to_self_delay, mut output, mut key_derivation_params, mut revocation_pubkey, } => {
 129                                 let (mut orig_key_derivation_params_0, mut orig_key_derivation_params_1) = key_derivation_params.to_rust(); let mut local_key_derivation_params = (orig_key_derivation_params_0, orig_key_derivation_params_1);
 130                                 nativeSpendableOutputDescriptor::DynamicOutputP2WSH {
 131                                         outpoint: *unsafe { Box::from_raw(outpoint.take_inner()) },
 132                                         per_commitment_point: per_commitment_point.into_rust(),
 133                                         to_self_delay: to_self_delay,
 134                                         output: output.into_rust(),
 135                                         key_derivation_params: local_key_derivation_params,
 136                                         revocation_pubkey: revocation_pubkey.into_rust(),
 137                                 }
 138                         },
 139                         SpendableOutputDescriptor::StaticOutputCounterpartyPayment {mut outpoint, mut output, mut key_derivation_params, } => {
 140                                 let (mut orig_key_derivation_params_0, mut orig_key_derivation_params_1) = key_derivation_params.to_rust(); let mut local_key_derivation_params = (orig_key_derivation_params_0, orig_key_derivation_params_1);
 141                                 nativeSpendableOutputDescriptor::StaticOutputCounterpartyPayment {
 142                                         outpoint: *unsafe { Box::from_raw(outpoint.take_inner()) },
 143                                         output: output.into_rust(),
 144                                         key_derivation_params: local_key_derivation_params,
 145                                 }
 146                         },
 147                 }
 148         }
 149         #[allow(unused)]
 150         pub(crate) fn from_native(native: &nativeSpendableOutputDescriptor) -> Self {
 151                 match native {
 152                         nativeSpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => {
 153                                 let mut outpoint_nonref = (*outpoint).clone();
 154                                 let mut output_nonref = (*output).clone();
 155                                 SpendableOutputDescriptor::StaticOutput {
 156                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true },
 157                                         output: crate::c_types::TxOut::from_rust(output_nonref),
 158                                 }
 159                         },
 160                         nativeSpendableOutputDescriptor::DynamicOutputP2WSH {ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref revocation_pubkey, } => {
 161                                 let mut outpoint_nonref = (*outpoint).clone();
 162                                 let mut per_commitment_point_nonref = (*per_commitment_point).clone();
 163                                 let mut to_self_delay_nonref = (*to_self_delay).clone();
 164                                 let mut output_nonref = (*output).clone();
 165                                 let mut key_derivation_params_nonref = (*key_derivation_params).clone();
 166                                 let (mut orig_key_derivation_params_nonref_0, mut orig_key_derivation_params_nonref_1) = key_derivation_params_nonref; let mut local_key_derivation_params_nonref = (orig_key_derivation_params_nonref_0, orig_key_derivation_params_nonref_1).into();
 167                                 let mut revocation_pubkey_nonref = (*revocation_pubkey).clone();
 168                                 SpendableOutputDescriptor::DynamicOutputP2WSH {
 169                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true },
 170                                         per_commitment_point: crate::c_types::PublicKey::from_rust(&per_commitment_point_nonref),
 171                                         to_self_delay: to_self_delay_nonref,
 172                                         output: crate::c_types::TxOut::from_rust(output_nonref),
 173                                         key_derivation_params: local_key_derivation_params_nonref,
 174                                         revocation_pubkey: crate::c_types::PublicKey::from_rust(&revocation_pubkey_nonref),
 175                                 }
 176                         },
 177                         nativeSpendableOutputDescriptor::StaticOutputCounterpartyPayment {ref outpoint, ref output, ref key_derivation_params, } => {
 178                                 let mut outpoint_nonref = (*outpoint).clone();
 179                                 let mut output_nonref = (*output).clone();
 180                                 let mut key_derivation_params_nonref = (*key_derivation_params).clone();
 181                                 let (mut orig_key_derivation_params_nonref_0, mut orig_key_derivation_params_nonref_1) = key_derivation_params_nonref; let mut local_key_derivation_params_nonref = (orig_key_derivation_params_nonref_0, orig_key_derivation_params_nonref_1).into();
 182                                 SpendableOutputDescriptor::StaticOutputCounterpartyPayment {
 183                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true },
 184                                         output: crate::c_types::TxOut::from_rust(output_nonref),
 185                                         key_derivation_params: local_key_derivation_params_nonref,
 186                                 }
 187                         },
 188                 }
 189         }
 190         #[allow(unused)]
 191         pub(crate) fn native_into(native: nativeSpendableOutputDescriptor) -> Self {
 192                 match native {
 193                         nativeSpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => {
 194                                 SpendableOutputDescriptor::StaticOutput {
 195                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true },
 196                                         output: crate::c_types::TxOut::from_rust(output),
 197                                 }
 198                         },
 199                         nativeSpendableOutputDescriptor::DynamicOutputP2WSH {mut outpoint, mut per_commitment_point, mut to_self_delay, mut output, mut key_derivation_params, mut revocation_pubkey, } => {
 200                                 let (mut orig_key_derivation_params_0, mut orig_key_derivation_params_1) = key_derivation_params; let mut local_key_derivation_params = (orig_key_derivation_params_0, orig_key_derivation_params_1).into();
 201                                 SpendableOutputDescriptor::DynamicOutputP2WSH {
 202                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true },
 203                                         per_commitment_point: crate::c_types::PublicKey::from_rust(&per_commitment_point),
 204                                         to_self_delay: to_self_delay,
 205                                         output: crate::c_types::TxOut::from_rust(output),
 206                                         key_derivation_params: local_key_derivation_params,
 207                                         revocation_pubkey: crate::c_types::PublicKey::from_rust(&revocation_pubkey),
 208                                 }
 209                         },
 210                         nativeSpendableOutputDescriptor::StaticOutputCounterpartyPayment {mut outpoint, mut output, mut key_derivation_params, } => {
 211                                 let (mut orig_key_derivation_params_0, mut orig_key_derivation_params_1) = key_derivation_params; let mut local_key_derivation_params = (orig_key_derivation_params_0, orig_key_derivation_params_1).into();
 212                                 SpendableOutputDescriptor::StaticOutputCounterpartyPayment {
 213                                         outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true },
 214                                         output: crate::c_types::TxOut::from_rust(output),
 215                                         key_derivation_params: local_key_derivation_params,
 216                                 }
 217                         },
 218                 }
 219         }
 220 }
 221 #[no_mangle]
 222 pub extern "C" fn SpendableOutputDescriptor_free(this_ptr: SpendableOutputDescriptor) { }
 223 #[no_mangle]
 224 pub extern "C" fn SpendableOutputDescriptor_clone(orig: &SpendableOutputDescriptor) -> SpendableOutputDescriptor {
 225         orig.clone()
 226 }
 227 #[no_mangle]
 228 pub extern "C" fn SpendableOutputDescriptor_write(obj: &SpendableOutputDescriptor) -> crate::c_types::derived::CVec_u8Z {
 229         crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
 230 }
 231 #[no_mangle]
 232 pub extern "C" fn SpendableOutputDescriptor_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_SpendableOutputDescriptorDecodeErrorZ {
 233         let res = crate::c_types::deserialize_obj(ser);
 234         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::chain::keysinterface::SpendableOutputDescriptor::native_into(o) }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) };
 235         local_res
 236 }
 237 /// Set of lightning keys needed to operate a channel as described in BOLT 3.
 238 ///
 239 /// Signing services could be implemented on a hardware wallet. In this case,
 240 /// the current ChannelKeys would be a front-end on top of a communication
 241 /// channel connected to your secure device and lightning key material wouldn't
 242 /// reside on a hot server. Nevertheless, a this deployment would still need
 243 /// to trust the ChannelManager to avoid loss of funds as this latest component
 244 /// could ask to sign commitment transaction with HTLCs paying to attacker pubkeys.
 245 ///
 246 /// A more secure iteration would be to use hashlock (or payment points) to pair
 247 /// invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager
 248 /// at the price of more state and computation on the hardware wallet side. In the future,
 249 /// we are looking forward to design such interface.
 250 ///
 251 /// In any case, ChannelMonitor or fallback watchtowers are always going to be trusted
 252 /// to act, as liveness and breach reply correctness are always going to be hard requirements
 253 /// of LN security model, orthogonal of key management issues.
 254 ///
 255 /// If you're implementing a custom signer, you almost certainly want to implement
 256 /// Readable/Writable to serialize out a unique reference to this set of keys so
 257 /// that you can serialize the full ChannelManager object.
 258 ///
 259 #[repr(C)]
 260 pub struct ChannelKeys {
 261         pub this_arg: *mut c_void,
 262         /// Gets the per-commitment point for a specific commitment number
 263         ///
 264         /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
 265         #[must_use]
 266         pub get_per_commitment_point: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::PublicKey,
 267         /// Gets the commitment secret for a specific commitment number as part of the revocation process
 268         ///
 269         /// An external signer implementation should error here if the commitment was already signed
 270         /// and should refuse to sign it in the future.
 271         ///
 272         /// May be called more than once for the same index.
 273         ///
 274         /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
 275         /// TODO: return a Result so we can signal a validation error
 276         #[must_use]
 277         pub release_commitment_secret: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::ThirtyTwoBytes,
 278         /// Gets the holder's channel public keys and basepoints
 279         pub pubkeys: crate::ln::chan_utils::ChannelPublicKeys,
 280         /// Fill in the pubkeys field as a reference to it will be given to Rust after this returns
 281         /// Note that this takes a pointer to this object, not the this_ptr like other methods do
 282         /// This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating.
 283         pub set_pubkeys: Option<extern "C" fn(&ChannelKeys)>,
 284         /// Gets arbitrary identifiers describing the set of keys which are provided back to you in
 285         /// some SpendableOutputDescriptor types. These should be sufficient to identify this
 286         /// ChannelKeys object uniquely and lookup or re-derive its keys.
 287         #[must_use]
 288         pub key_derivation_params: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::C2Tuple_u64u64Z,
 289         /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
 290         ///
 291         /// Note that if signing fails or is rejected, the channel will be force-closed.
 292         #[must_use]
 293         pub sign_counterparty_commitment: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::ln::chan_utils::CommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ,
 294         /// Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
 295         /// This will only ever be called with a non-revoked commitment_tx.  This will be called with the
 296         /// latest commitment_tx when we initiate a force-close.
 297         /// This will be called with the previous latest, just to get claiming HTLC signatures, if we are
 298         /// reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
 299         /// the latest.
 300         /// This may be called multiple times for the same transaction.
 301         ///
 302         /// An external signer implementation should check that the commitment has not been revoked.
 303         ///
 304         /// May return Err if key derivation fails.  Callers, such as ChannelMonitor, will panic in such a case.
 305         #[must_use]
 306         pub sign_holder_commitment_and_htlcs: extern "C" fn (this_arg: *const c_void, commitment_tx: &crate::ln::chan_utils::HolderCommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ,
 307         /// Create a signature for the given input in a transaction spending an HTLC or commitment
 308         /// transaction output when our counterparty broadcasts an old state.
 309         ///
 310         /// A justice transaction may claim multiples outputs at the same time if timelocks are
 311         /// similar, but only a signature for the input at index `input` should be signed for here.
 312         /// It may be called multiples time for same output(s) if a fee-bump is needed with regards
 313         /// to an upcoming timelock expiration.
 314         ///
 315         /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 316         ///
 317         /// per_commitment_key is revocation secret which was provided by our counterparty when they
 318         /// revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 319         /// not allow the spending of any funds by itself (you need our holder revocation_secret to do
 320         /// so).
 321         ///
 322         /// htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
 323         /// changing the format of the witness script (which is committed to in the BIP 143
 324         /// signatures).
 325         #[must_use]
 326         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::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ,
 327         /// Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
 328         /// transaction, either offered or received.
 329         ///
 330         /// Such a transaction may claim multiples offered outputs at same time if we know the
 331         /// preimage for each when we create it, but only the input at index `input` should be
 332         /// signed for here. It may be called multiple times for same output(s) if a fee-bump is
 333         /// needed with regards to an upcoming timelock expiration.
 334         ///
 335         /// Witness_script is either a offered or received script as defined in BOLT3 for HTLC
 336         /// outputs.
 337         ///
 338         /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 339         ///
 340         /// Per_commitment_point is the dynamic point corresponding to the channel state
 341         /// detected onchain. It has been generated by our counterparty and is used to derive
 342         /// channel state keys, which are then included in the witness script and committed to in the
 343         /// BIP 143 signature.
 344         #[must_use]
 345         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::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ,
 346         /// Create a signature for a (proposed) closing transaction.
 347         ///
 348         /// Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have
 349         /// chosen to forgo their output as dust.
 350         #[must_use]
 351         pub sign_closing_transaction: extern "C" fn (this_arg: *const c_void, closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ,
 352         /// Signs a channel announcement message with our funding key, proving it comes from one
 353         /// of the channel participants.
 354         ///
 355         /// Note that if this fails or is rejected, the channel will not be publicly announced and
 356         /// our counterparty may (though likely will not) close the channel on us for violating the
 357         /// protocol.
 358         #[must_use]
 359         pub sign_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ,
 360         /// Set the counterparty static channel data, including basepoints,
 361         /// counterparty_selected/holder_selected_contest_delay and funding outpoint.
 362         /// This is done as soon as the funding outpoint is known.  Since these are static channel data,
 363         /// they MUST NOT be allowed to change to different values once set.
 364         ///
 365         /// channel_parameters.is_populated() MUST be true.
 366         ///
 367         /// We bind holder_selected_contest_delay late here for API convenience.
 368         ///
 369         /// Will be called before any signatures are applied.
 370         pub ready_channel: extern "C" fn (this_arg: *mut c_void, channel_parameters: &crate::ln::chan_utils::ChannelTransactionParameters),
 371         pub clone: Option<extern "C" fn (this_arg: *const c_void) -> *mut c_void>,
 372         pub write: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 373         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 374 }
 375 unsafe impl Send for ChannelKeys {}
 376 #[no_mangle]
 377 pub extern "C" fn ChannelKeys_clone(orig: &ChannelKeys) -> ChannelKeys {
 378         ChannelKeys {
 379                 this_arg: if let Some(f) = orig.clone { (f)(orig.this_arg) } else { orig.this_arg },
 380                 get_per_commitment_point: orig.get_per_commitment_point.clone(),
 381                 release_commitment_secret: orig.release_commitment_secret.clone(),
 382                 pubkeys: orig.pubkeys.clone(),
 383                 set_pubkeys: orig.set_pubkeys.clone(),
 384                 key_derivation_params: orig.key_derivation_params.clone(),
 385                 sign_counterparty_commitment: orig.sign_counterparty_commitment.clone(),
 386                 sign_holder_commitment_and_htlcs: orig.sign_holder_commitment_and_htlcs.clone(),
 387                 sign_justice_transaction: orig.sign_justice_transaction.clone(),
 388                 sign_counterparty_htlc_transaction: orig.sign_counterparty_htlc_transaction.clone(),
 389                 sign_closing_transaction: orig.sign_closing_transaction.clone(),
 390                 sign_channel_announcement: orig.sign_channel_announcement.clone(),
 391                 ready_channel: orig.ready_channel.clone(),
 392                 clone: orig.clone.clone(),
 393                 write: orig.write.clone(),
 394                 free: orig.free.clone(),
 395         }
 396 }
 397 impl Clone for ChannelKeys {
 398         fn clone(&self) -> Self {
 399                 ChannelKeys_clone(self)
 400         }
 401 }
 402 impl lightning::util::ser::Writeable for ChannelKeys {
 403         fn write<W: lightning::util::ser::Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 404                 let vec = (self.write)(self.this_arg);
 405                 w.write_all(vec.as_slice())
 406         }
 407 }
 408
 409 use lightning::chain::keysinterface::ChannelKeys as rustChannelKeys;
 410 impl rustChannelKeys for ChannelKeys {
 411         fn get_per_commitment_point<T:bitcoin::secp256k1::Signing + bitcoin::secp256k1::Verification>(&self, idx: u64, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> bitcoin::secp256k1::key::PublicKey {
 412                 let mut ret = (self.get_per_commitment_point)(self.this_arg, idx);
 413                 ret.into_rust()
 414         }
 415         fn release_commitment_secret(&self, idx: u64) -> [u8; 32] {
 416                 let mut ret = (self.release_commitment_secret)(self.this_arg, idx);
 417                 ret.data
 418         }
 419         fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys {
 420                 if let Some(f) = self.set_pubkeys {
 421                         (f)(self);
 422                 }
 423                 unsafe { &*self.pubkeys.inner }
 424         }
 425         fn key_derivation_params(&self) -> (u64, u64) {
 426                 let mut ret = (self.key_derivation_params)(self.this_arg);
 427                 let (mut orig_ret_0, mut orig_ret_1) = ret.to_rust(); let mut local_ret = (orig_ret_0, orig_ret_1);
 428                 local_ret
 429         }
 430         fn sign_counterparty_commitment<T:bitcoin::secp256k1::Signing + bitcoin::secp256k1::Verification>(&self, commitment_tx: &lightning::ln::chan_utils::CommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 431                 let mut ret = (self.sign_counterparty_commitment)(self.this_arg, &crate::ln::chan_utils::CommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 432                 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)) })*/ })};
 433                 local_ret
 434         }
 435         fn sign_holder_commitment_and_htlcs<T:bitcoin::secp256k1::Signing + bitcoin::secp256k1::Verification>(&self, commitment_tx: &lightning::ln::chan_utils::HolderCommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<(bitcoin::secp256k1::Signature, Vec<bitcoin::secp256k1::Signature>), ()> {
 436                 let mut ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, &crate::ln::chan_utils::HolderCommitmentTransaction { inner: unsafe { (commitment_tx as *const _) as *mut _ }, is_owned: false });
 437                 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)) })*/ })};
 438                 local_ret
 439         }
 440         fn sign_justice_transaction<T:bitcoin::secp256k1::Signing + bitcoin::secp256k1::Verification>(&self, justice_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_key: &bitcoin::secp256k1::key::SecretKey, htlc: &Option<lightning::ln::chan_utils::HTLCOutputInCommitment>, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<bitcoin::secp256k1::Signature, ()> {
 441                 let mut local_justice_tx = ::bitcoin::consensus::encode::serialize(justice_tx);
 442                 let mut local_htlc = &crate::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 };
 443                 let mut ret = (self.sign_justice_transaction)(self.this_arg, crate::c_types::Transaction::from_vec(local_justice_tx), input, amount, per_commitment_key.as_ref(), local_htlc);
 444                 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)) })*/ })};
 445                 local_ret
 446         }
 447         fn sign_counterparty_htlc_transaction<T:bitcoin::secp256k1::Signing + bitcoin::secp256k1::Verification>(&self, htlc_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_point: &bitcoin::secp256k1::key::PublicKey, htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<bitcoin::secp256k1::Signature, ()> {
 448                 let mut local_htlc_tx = ::bitcoin::consensus::encode::serialize(htlc_tx);
 449                 let mut ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, crate::c_types::Transaction::from_vec(local_htlc_tx), input, amount, crate::c_types::PublicKey::from_rust(&per_commitment_point), &crate::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { (htlc as *const _) as *mut _ }, is_owned: false });
 450                 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)) })*/ })};
 451                 local_ret
 452         }
 453         fn sign_closing_transaction<T:bitcoin::secp256k1::Signing>(&self, closing_tx: &bitcoin::blockdata::transaction::Transaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<bitcoin::secp256k1::Signature, ()> {
 454                 let mut local_closing_tx = ::bitcoin::consensus::encode::serialize(closing_tx);
 455                 let mut ret = (self.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_vec(local_closing_tx));
 456                 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)) })*/ })};
 457                 local_ret
 458         }
 459         fn sign_channel_announcement<T:bitcoin::secp256k1::Signing>(&self, msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, _secp_ctx: &bitcoin::secp256k1::Secp256k1<T>) -> Result<bitcoin::secp256k1::Signature, ()> {
 460                 let mut ret = (self.sign_channel_announcement)(self.this_arg, &crate::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
 461                 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)) })*/ })};
 462                 local_ret
 463         }
 464         fn ready_channel(&mut self, channel_parameters: &lightning::ln::chan_utils::ChannelTransactionParameters) {
 465                 (self.ready_channel)(self.this_arg, &crate::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { (channel_parameters as *const _) as *mut _ }, is_owned: false })
 466         }
 467 }
 468
 469 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 470 // directly as a Deref trait in higher-level structs:
 471 impl std::ops::Deref for ChannelKeys {
 472         type Target = Self;
 473         fn deref(&self) -> &Self {
 474                 self
 475         }
 476 }
 477 /// Calls the free function if one is set
 478 #[no_mangle]
 479 pub extern "C" fn ChannelKeys_free(this_ptr: ChannelKeys) { }
 480 impl Drop for ChannelKeys {
 481         fn drop(&mut self) {
 482                 if let Some(f) = self.free {
 483                         f(self.this_arg);
 484                 }
 485         }
 486 }
 487 /// A trait to describe an object which can get user secrets and key material.
 488 #[repr(C)]
 489 pub struct KeysInterface {
 490         pub this_arg: *mut c_void,
 491         /// Get node secret key (aka node_id or network_key)
 492         #[must_use]
 493         pub get_node_secret: extern "C" fn (this_arg: *const c_void) -> crate::c_types::SecretKey,
 494         /// Get destination redeemScript to encumber static protocol exit points.
 495         #[must_use]
 496         pub get_destination_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z,
 497         /// Get shutdown_pubkey to use as PublicKey at channel closure
 498         #[must_use]
 499         pub get_shutdown_pubkey: extern "C" fn (this_arg: *const c_void) -> crate::c_types::PublicKey,
 500         /// Get a new set of ChannelKeys for per-channel secrets. These MUST be unique even if you
 501         /// restarted with some stale data!
 502         #[must_use]
 503         pub get_channel_keys: extern "C" fn (this_arg: *const c_void, inbound: bool, channel_value_satoshis: u64) -> crate::chain::keysinterface::ChannelKeys,
 504         /// Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
 505         /// onion packets and for temporary channel IDs. There is no requirement that these be
 506         /// persisted anywhere, though they must be unique across restarts.
 507         #[must_use]
 508         pub get_secure_random_bytes: extern "C" fn (this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes,
 509         /// Reads a `ChanKeySigner` for this `KeysInterface` from the given input stream.
 510         /// This is only called during deserialization of other objects which contain
 511         /// `ChannelKeys`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
 512         /// The bytes are exactly those which `<Self::ChanKeySigner as Writeable>::write()` writes, and
 513         /// contain no versioning scheme. You may wish to include your own version prefix and ensure
 514         /// you've read all of the provided bytes to ensure no corruption occurred.
 515         #[must_use]
 516         pub read_chan_signer: extern "C" fn (this_arg: *const c_void, reader: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChanKeySignerDecodeErrorZ,
 517         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 518 }
 519 unsafe impl Send for KeysInterface {}
 520 unsafe impl Sync for KeysInterface {}
 521
 522 use lightning::chain::keysinterface::KeysInterface as rustKeysInterface;
 523 impl rustKeysInterface for KeysInterface {
 524         type ChanKeySigner = crate::chain::keysinterface::ChannelKeys;
 525         fn get_node_secret(&self) -> bitcoin::secp256k1::key::SecretKey {
 526                 let mut ret = (self.get_node_secret)(self.this_arg);
 527                 ret.into_rust()
 528         }
 529         fn get_destination_script(&self) -> bitcoin::blockdata::script::Script {
 530                 let mut ret = (self.get_destination_script)(self.this_arg);
 531                 ::bitcoin::blockdata::script::Script::from(ret.into_rust())
 532         }
 533         fn get_shutdown_pubkey(&self) -> bitcoin::secp256k1::key::PublicKey {
 534                 let mut ret = (self.get_shutdown_pubkey)(self.this_arg);
 535                 ret.into_rust()
 536         }
 537         fn get_channel_keys(&self, inbound: bool, channel_value_satoshis: u64) -> crate::chain::keysinterface::ChannelKeys {
 538                 let mut ret = (self.get_channel_keys)(self.this_arg, inbound, channel_value_satoshis);
 539                 ret
 540         }
 541         fn get_secure_random_bytes(&self) -> [u8; 32] {
 542                 let mut ret = (self.get_secure_random_bytes)(self.this_arg);
 543                 ret.data
 544         }
 545         fn read_chan_signer(&self, reader: &[u8]) -> Result<crate::chain::keysinterface::ChannelKeys, lightning::ln::msgs::DecodeError> {
 546                 let mut local_reader = crate::c_types::u8slice::from_slice(reader);
 547                 let mut ret = (self.read_chan_signer)(self.this_arg, local_reader);
 548                 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()) } })};
 549                 local_ret
 550         }
 551 }
 552
 553 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 554 // directly as a Deref trait in higher-level structs:
 555 impl std::ops::Deref for KeysInterface {
 556         type Target = Self;
 557         fn deref(&self) -> &Self {
 558                 self
 559         }
 560 }
 561 /// Calls the free function if one is set
 562 #[no_mangle]
 563 pub extern "C" fn KeysInterface_free(this_ptr: KeysInterface) { }
 564 impl Drop for KeysInterface {
 565         fn drop(&mut self) {
 566                 if let Some(f) = self.free {
 567                         f(self.this_arg);
 568                 }
 569         }
 570 }
 571
 572 use lightning::chain::keysinterface::InMemoryChannelKeys as nativeInMemoryChannelKeysImport;
 573 type nativeInMemoryChannelKeys = nativeInMemoryChannelKeysImport;
 574
 575 /// A simple implementation of ChannelKeys that just keeps the private keys in memory.
 576 ///
 577 /// This implementation performs no policy checks and is insufficient by itself as
 578 /// a secure external signer.
 579 #[must_use]
 580 #[repr(C)]
 581 pub struct InMemoryChannelKeys {
 582         /// Nearly everywhere, inner must be non-null, however in places where
 583         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 584         pub inner: *mut nativeInMemoryChannelKeys,
 585         pub is_owned: bool,
 586 }
 587
 588 impl Drop for InMemoryChannelKeys {
 589         fn drop(&mut self) {
 590                 if self.is_owned && !self.inner.is_null() {
 591                         let _ = unsafe { Box::from_raw(self.inner) };
 592                 }
 593         }
 594 }
 595 #[no_mangle]
 596 pub extern "C" fn InMemoryChannelKeys_free(this_ptr: InMemoryChannelKeys) { }
 597 #[allow(unused)]
 598 /// Used only if an object of this type is returned as a trait impl by a method
 599 extern "C" fn InMemoryChannelKeys_free_void(this_ptr: *mut c_void) {
 600         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInMemoryChannelKeys); }
 601 }
 602 #[allow(unused)]
 603 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 604 impl InMemoryChannelKeys {
 605         pub(crate) fn take_inner(mut self) -> *mut nativeInMemoryChannelKeys {
 606                 assert!(self.is_owned);
 607                 let ret = self.inner;
 608                 self.inner = std::ptr::null_mut();
 609                 ret
 610         }
 611 }
 612 impl Clone for InMemoryChannelKeys {
 613         fn clone(&self) -> Self {
 614                 Self {
 615                         inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())),
 616                         is_owned: true,
 617                 }
 618         }
 619 }
 620 #[allow(unused)]
 621 /// Used only if an object of this type is returned as a trait impl by a method
 622 pub(crate) extern "C" fn InMemoryChannelKeys_clone_void(this_ptr: *const c_void) -> *mut c_void {
 623         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInMemoryChannelKeys)).clone() })) as *mut c_void
 624 }
 625 #[no_mangle]
 626 pub extern "C" fn InMemoryChannelKeys_clone(orig: &InMemoryChannelKeys) -> InMemoryChannelKeys {
 627         InMemoryChannelKeys { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true }
 628 }
 629 /// Private key of anchor tx
 630 #[no_mangle]
 631 pub extern "C" fn InMemoryChannelKeys_get_funding_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 632         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_key;
 633         (*inner_val).as_ref()
 634 }
 635 /// Private key of anchor tx
 636 #[no_mangle]
 637 pub extern "C" fn InMemoryChannelKeys_set_funding_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) {
 638         unsafe { &mut *this_ptr.inner }.funding_key = val.into_rust();
 639 }
 640 /// Holder secret key for blinded revocation pubkey
 641 #[no_mangle]
 642 pub extern "C" fn InMemoryChannelKeys_get_revocation_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 643         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_base_key;
 644         (*inner_val).as_ref()
 645 }
 646 /// Holder secret key for blinded revocation pubkey
 647 #[no_mangle]
 648 pub extern "C" fn InMemoryChannelKeys_set_revocation_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) {
 649         unsafe { &mut *this_ptr.inner }.revocation_base_key = val.into_rust();
 650 }
 651 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 652 #[no_mangle]
 653 pub extern "C" fn InMemoryChannelKeys_get_payment_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 654         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_key;
 655         (*inner_val).as_ref()
 656 }
 657 /// Holder secret key used for our balance in counterparty-broadcasted commitment transactions
 658 #[no_mangle]
 659 pub extern "C" fn InMemoryChannelKeys_set_payment_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) {
 660         unsafe { &mut *this_ptr.inner }.payment_key = val.into_rust();
 661 }
 662 /// Holder secret key used in HTLC tx
 663 #[no_mangle]
 664 pub extern "C" fn InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 665         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_base_key;
 666         (*inner_val).as_ref()
 667 }
 668 /// Holder secret key used in HTLC tx
 669 #[no_mangle]
 670 pub extern "C" fn InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) {
 671         unsafe { &mut *this_ptr.inner }.delayed_payment_base_key = val.into_rust();
 672 }
 673 /// Holder htlc secret key used in commitment tx htlc outputs
 674 #[no_mangle]
 675 pub extern "C" fn InMemoryChannelKeys_get_htlc_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 676         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_base_key;
 677         (*inner_val).as_ref()
 678 }
 679 /// Holder htlc secret key used in commitment tx htlc outputs
 680 #[no_mangle]
 681 pub extern "C" fn InMemoryChannelKeys_set_htlc_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) {
 682         unsafe { &mut *this_ptr.inner }.htlc_base_key = val.into_rust();
 683 }
 684 /// Commitment seed
 685 #[no_mangle]
 686 pub extern "C" fn InMemoryChannelKeys_get_commitment_seed(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] {
 687         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_seed;
 688         &(*inner_val)
 689 }
 690 /// Commitment seed
 691 #[no_mangle]
 692 pub extern "C" fn InMemoryChannelKeys_set_commitment_seed(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::ThirtyTwoBytes) {
 693         unsafe { &mut *this_ptr.inner }.commitment_seed = val.data;
 694 }
 695 /// Create a new InMemoryChannelKeys
 696 #[must_use]
 697 #[no_mangle]
 698 pub extern "C" fn InMemoryChannelKeys_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 key_derivation_params: crate::c_types::derived::C2Tuple_u64u64Z) -> crate::chain::keysinterface::InMemoryChannelKeys {
 699         let (mut orig_key_derivation_params_0, mut orig_key_derivation_params_1) = key_derivation_params.to_rust(); let mut local_key_derivation_params = (orig_key_derivation_params_0, orig_key_derivation_params_1);
 700         let mut ret = lightning::chain::keysinterface::InMemoryChannelKeys::new(&bitcoin::secp256k1::Secp256k1::new(), 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, local_key_derivation_params);
 701         crate::chain::keysinterface::InMemoryChannelKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true }
 702 }
 703
 704 /// Counterparty pubkeys.
 705 /// Will panic if ready_channel wasn't called.
 706 #[must_use]
 707 #[no_mangle]
 708 pub extern "C" fn InMemoryChannelKeys_counterparty_pubkeys(this_arg: &InMemoryChannelKeys) -> crate::ln::chan_utils::ChannelPublicKeys {
 709         let mut ret = unsafe { &*this_arg.inner }.counterparty_pubkeys();
 710         crate::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
 711 }
 712
 713 /// The contest_delay value specified by our counterparty and applied on holder-broadcastable
 714 /// transactions, ie the amount of time that we have to wait to recover our funds if we
 715 /// broadcast a transaction.
 716 /// Will panic if ready_channel wasn't called.
 717 #[must_use]
 718 #[no_mangle]
 719 pub extern "C" fn InMemoryChannelKeys_counterparty_selected_contest_delay(this_arg: &InMemoryChannelKeys) -> u16 {
 720         let mut ret = unsafe { &*this_arg.inner }.counterparty_selected_contest_delay();
 721         ret
 722 }
 723
 724 /// The contest_delay value specified by us and applied on transactions broadcastable
 725 /// by our counterparty, ie the amount of time that they have to wait to recover their funds
 726 /// if they broadcast a transaction.
 727 /// Will panic if ready_channel wasn't called.
 728 #[must_use]
 729 #[no_mangle]
 730 pub extern "C" fn InMemoryChannelKeys_holder_selected_contest_delay(this_arg: &InMemoryChannelKeys) -> u16 {
 731         let mut ret = unsafe { &*this_arg.inner }.holder_selected_contest_delay();
 732         ret
 733 }
 734
 735 /// Whether the holder is the initiator
 736 /// Will panic if ready_channel wasn't called.
 737 #[must_use]
 738 #[no_mangle]
 739 pub extern "C" fn InMemoryChannelKeys_is_outbound(this_arg: &InMemoryChannelKeys) -> bool {
 740         let mut ret = unsafe { &*this_arg.inner }.is_outbound();
 741         ret
 742 }
 743
 744 /// Funding outpoint
 745 /// Will panic if ready_channel wasn't called.
 746 #[must_use]
 747 #[no_mangle]
 748 pub extern "C" fn InMemoryChannelKeys_funding_outpoint(this_arg: &InMemoryChannelKeys) -> crate::chain::transaction::OutPoint {
 749         let mut ret = unsafe { &*this_arg.inner }.funding_outpoint();
 750         crate::chain::transaction::OutPoint { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
 751 }
 752
 753 /// Obtain a ChannelTransactionParameters for this channel, to be used when verifying or
 754 /// building transactions.
 755 ///
 756 /// Will panic if ready_channel wasn't called.
 757 #[must_use]
 758 #[no_mangle]
 759 pub extern "C" fn InMemoryChannelKeys_get_channel_parameters(this_arg: &InMemoryChannelKeys) -> crate::ln::chan_utils::ChannelTransactionParameters {
 760         let mut ret = unsafe { &*this_arg.inner }.get_channel_parameters();
 761         crate::ln::chan_utils::ChannelTransactionParameters { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
 762 }
 763
 764 impl From<nativeInMemoryChannelKeys> for crate::chain::keysinterface::ChannelKeys {
 765         fn from(obj: nativeInMemoryChannelKeys) -> Self {
 766                 let mut rust_obj = InMemoryChannelKeys { inner: Box::into_raw(Box::new(obj)), is_owned: true };
 767                 let mut ret = InMemoryChannelKeys_as_ChannelKeys(&rust_obj);
 768                 // 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
 769                 rust_obj.inner = std::ptr::null_mut();
 770                 ret.free = Some(InMemoryChannelKeys_free_void);
 771                 ret
 772         }
 773 }
 774 #[no_mangle]
 775 pub extern "C" fn InMemoryChannelKeys_as_ChannelKeys(this_arg: &InMemoryChannelKeys) -> crate::chain::keysinterface::ChannelKeys {
 776         crate::chain::keysinterface::ChannelKeys {
 777                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
 778                 free: None,
 779                 get_per_commitment_point: InMemoryChannelKeys_ChannelKeys_get_per_commitment_point,
 780                 release_commitment_secret: InMemoryChannelKeys_ChannelKeys_release_commitment_secret,
 781
 782                 pubkeys: crate::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true },
 783                 set_pubkeys: Some(InMemoryChannelKeys_ChannelKeys_set_pubkeys),
 784                 key_derivation_params: InMemoryChannelKeys_ChannelKeys_key_derivation_params,
 785                 sign_counterparty_commitment: InMemoryChannelKeys_ChannelKeys_sign_counterparty_commitment,
 786                 sign_holder_commitment_and_htlcs: InMemoryChannelKeys_ChannelKeys_sign_holder_commitment_and_htlcs,
 787                 sign_justice_transaction: InMemoryChannelKeys_ChannelKeys_sign_justice_transaction,
 788                 sign_counterparty_htlc_transaction: InMemoryChannelKeys_ChannelKeys_sign_counterparty_htlc_transaction,
 789                 sign_closing_transaction: InMemoryChannelKeys_ChannelKeys_sign_closing_transaction,
 790                 sign_channel_announcement: InMemoryChannelKeys_ChannelKeys_sign_channel_announcement,
 791                 ready_channel: InMemoryChannelKeys_ChannelKeys_ready_channel,
 792                 clone: Some(InMemoryChannelKeys_clone_void),
 793                 write: InMemoryChannelKeys_write_void,
 794         }
 795 }
 796 use lightning::chain::keysinterface::ChannelKeys as ChannelKeysTraitImport;
 797 #[must_use]
 798 extern "C" fn InMemoryChannelKeys_ChannelKeys_get_per_commitment_point(this_arg: *const c_void, mut idx: u64) -> crate::c_types::PublicKey {
 799         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.get_per_commitment_point(idx, &bitcoin::secp256k1::Secp256k1::new());
 800         crate::c_types::PublicKey::from_rust(&ret)
 801 }
 802 #[must_use]
 803 extern "C" fn InMemoryChannelKeys_ChannelKeys_release_commitment_secret(this_arg: *const c_void, mut idx: u64) -> crate::c_types::ThirtyTwoBytes {
 804         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.release_commitment_secret(idx);
 805         crate::c_types::ThirtyTwoBytes { data: ret }
 806 }
 807 #[must_use]
 808 extern "C" fn InMemoryChannelKeys_ChannelKeys_pubkeys(this_arg: *const c_void) -> crate::ln::chan_utils::ChannelPublicKeys {
 809         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.pubkeys();
 810         crate::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false }
 811 }
 812 extern "C" fn InMemoryChannelKeys_ChannelKeys_set_pubkeys(trait_self_arg: &ChannelKeys) {
 813         // This is a bit race-y in the general case, but for our specific use-cases today, we're safe
 814         // Specifically, we must ensure that the first time we're called it can never be in parallel
 815         if trait_self_arg.pubkeys.inner.is_null() {
 816                 unsafe { &mut *(trait_self_arg as *const ChannelKeys  as *mut ChannelKeys) }.pubkeys = InMemoryChannelKeys_ChannelKeys_pubkeys(trait_self_arg.this_arg);
 817         }
 818 }
 819 #[must_use]
 820 extern "C" fn InMemoryChannelKeys_ChannelKeys_key_derivation_params(this_arg: *const c_void) -> crate::c_types::derived::C2Tuple_u64u64Z {
 821         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.key_derivation_params();
 822         let (mut orig_ret_0, mut orig_ret_1) = ret; let mut local_ret = (orig_ret_0, orig_ret_1).into();
 823         local_ret
 824 }
 825 #[must_use]
 826 extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_counterparty_commitment(this_arg: *const c_void, commitment_tx: &crate::ln::chan_utils::CommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 827         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_counterparty_commitment(unsafe { &*commitment_tx.inner }, &bitcoin::secp256k1::Secp256k1::new());
 828         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 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 }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 829         local_ret
 830 }
 831 #[must_use]
 832 extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_holder_commitment_and_htlcs(this_arg: *const c_void, commitment_tx: &crate::ln::chan_utils::HolderCommitmentTransaction) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 833         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_holder_commitment_and_htlcs(unsafe { &*commitment_tx.inner }, &bitcoin::secp256k1::Secp256k1::new());
 834         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 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 }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 835         local_ret
 836 }
 837 #[must_use]
 838 extern "C" fn InMemoryChannelKeys_ChannelKeys_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::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ {
 839         let mut local_htlc = if htlc.inner.is_null() { None } else { Some((* { unsafe { &*htlc.inner } }).clone()) };
 840         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_justice_transaction(&justice_tx.into_bitcoin(), input, amount, &::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *per_commitment_key}[..]).unwrap(), &local_htlc, &bitcoin::secp256k1::Secp256k1::new());
 841         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 842         local_ret
 843 }
 844 #[must_use]
 845 extern "C" fn InMemoryChannelKeys_ChannelKeys_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::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ {
 846         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_counterparty_htlc_transaction(&htlc_tx.into_bitcoin(), input, amount, &per_commitment_point.into_rust(), unsafe { &*htlc.inner }, &bitcoin::secp256k1::Secp256k1::new());
 847         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 848         local_ret
 849 }
 850 #[must_use]
 851 extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_closing_transaction(this_arg: *const c_void, mut closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ {
 852         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_closing_transaction(&closing_tx.into_bitcoin(), &bitcoin::secp256k1::Secp256k1::new());
 853         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 854         local_ret
 855 }
 856 #[must_use]
 857 extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_channel_announcement(this_arg: *const c_void, msg: &crate::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ {
 858         let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_channel_announcement(unsafe { &*msg.inner }, &bitcoin::secp256k1::Secp256k1::new());
 859         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::Signature::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) };
 860         local_ret
 861 }
 862 extern "C" fn InMemoryChannelKeys_ChannelKeys_ready_channel(this_arg: *mut c_void, channel_parameters: &crate::ln::chan_utils::ChannelTransactionParameters) {
 863         unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.ready_channel(unsafe { &*channel_parameters.inner })
 864 }
 865
 866 #[no_mangle]
 867 pub extern "C" fn InMemoryChannelKeys_write(obj: &InMemoryChannelKeys) -> crate::c_types::derived::CVec_u8Z {
 868         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
 869 }
 870 #[no_mangle]
 871 pub(crate) extern "C" fn InMemoryChannelKeys_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 872         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInMemoryChannelKeys) })
 873 }
 874 #[no_mangle]
 875 pub extern "C" fn InMemoryChannelKeys_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InMemoryChannelKeysDecodeErrorZ {
 876         let res = crate::c_types::deserialize_obj(ser);
 877         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::chain::keysinterface::InMemoryChannelKeys { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) };
 878         local_res
 879 }
 880
 881 use lightning::chain::keysinterface::KeysManager as nativeKeysManagerImport;
 882 type nativeKeysManager = nativeKeysManagerImport;
 883
 884 /// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
 885 /// and derives keys from that.
 886 ///
 887 /// Your node_id is seed/0'
 888 /// ChannelMonitor closes may use seed/1'
 889 /// Cooperative closes may use seed/2'
 890 /// The two close keys may be needed to claim on-chain funds!
 891 #[must_use]
 892 #[repr(C)]
 893 pub struct KeysManager {
 894         /// Nearly everywhere, inner must be non-null, however in places where
 895         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 896         pub inner: *mut nativeKeysManager,
 897         pub is_owned: bool,
 898 }
 899
 900 impl Drop for KeysManager {
 901         fn drop(&mut self) {
 902                 if self.is_owned && !self.inner.is_null() {
 903                         let _ = unsafe { Box::from_raw(self.inner) };
 904                 }
 905         }
 906 }
 907 #[no_mangle]
 908 pub extern "C" fn KeysManager_free(this_ptr: KeysManager) { }
 909 #[allow(unused)]
 910 /// Used only if an object of this type is returned as a trait impl by a method
 911 extern "C" fn KeysManager_free_void(this_ptr: *mut c_void) {
 912         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeKeysManager); }
 913 }
 914 #[allow(unused)]
 915 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 916 impl KeysManager {
 917         pub(crate) fn take_inner(mut self) -> *mut nativeKeysManager {
 918                 assert!(self.is_owned);
 919                 let ret = self.inner;
 920                 self.inner = std::ptr::null_mut();
 921                 ret
 922         }
 923 }
 924 /// Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
 925 /// CSRNG is busted) this may panic (but more importantly, you will possibly lose funds).
 926 /// starting_time isn't strictly required to actually be a time, but it must absolutely,
 927 /// without a doubt, be unique to this instance. ie if you start multiple times with the same
 928 /// seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to
 929 /// simply use the current time (with very high precision).
 930 ///
 931 /// The seed MUST be backed up safely prior to use so that the keys can be re-created, however,
 932 /// obviously, starting_time should be unique every time you reload the library - it is only
 933 /// used to generate new ephemeral key data (which will be stored by the individual channel if
 934 /// necessary).
 935 ///
 936 /// Note that the seed is required to recover certain on-chain funds independent of
 937 /// ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any
 938 /// channel, and some on-chain during-closing funds.
 939 ///
 940 /// Note that until the 0.1 release there is no guarantee of backward compatibility between
 941 /// versions. Once the library is more fully supported, the docs will be updated to include a
 942 /// detailed description of the guarantee.
 943 #[must_use]
 944 #[no_mangle]
 945 pub extern "C" fn KeysManager_new(seed: *const [u8; 32], mut network: crate::bitcoin::network::Network, mut starting_time_secs: u64, mut starting_time_nanos: u32) -> KeysManager {
 946         let mut ret = lightning::chain::keysinterface::KeysManager::new(unsafe { &*seed}, network.into_bitcoin(), starting_time_secs, starting_time_nanos);
 947         KeysManager { inner: Box::into_raw(Box::new(ret)), is_owned: true }
 948 }
 949
 950 /// Derive an old set of ChannelKeys for per-channel secrets based on a key derivation
 951 /// parameters.
 952 /// Key derivation parameters are accessible through a per-channel secrets
 953 /// ChannelKeys::key_derivation_params and is provided inside DynamicOuputP2WSH in case of
 954 /// onchain output detection for which a corresponding delayed_payment_key must be derived.
 955 #[must_use]
 956 #[no_mangle]
 957 pub extern "C" fn KeysManager_derive_channel_keys(this_arg: &KeysManager, mut channel_value_satoshis: u64, mut params_1: u64, mut params_2: u64) -> crate::chain::keysinterface::InMemoryChannelKeys {
 958         let mut ret = unsafe { &*this_arg.inner }.derive_channel_keys(channel_value_satoshis, params_1, params_2);
 959         crate::chain::keysinterface::InMemoryChannelKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true }
 960 }
 961
 962 impl From<nativeKeysManager> for crate::chain::keysinterface::KeysInterface {
 963         fn from(obj: nativeKeysManager) -> Self {
 964                 let mut rust_obj = KeysManager { inner: Box::into_raw(Box::new(obj)), is_owned: true };
 965                 let mut ret = KeysManager_as_KeysInterface(&rust_obj);
 966                 // 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
 967                 rust_obj.inner = std::ptr::null_mut();
 968                 ret.free = Some(KeysManager_free_void);
 969                 ret
 970         }
 971 }
 972 #[no_mangle]
 973 pub extern "C" fn KeysManager_as_KeysInterface(this_arg: &KeysManager) -> crate::chain::keysinterface::KeysInterface {
 974         crate::chain::keysinterface::KeysInterface {
 975                 this_arg: unsafe { (*this_arg).inner as *mut c_void },
 976                 free: None,
 977                 get_node_secret: KeysManager_KeysInterface_get_node_secret,
 978                 get_destination_script: KeysManager_KeysInterface_get_destination_script,
 979                 get_shutdown_pubkey: KeysManager_KeysInterface_get_shutdown_pubkey,
 980                 get_channel_keys: KeysManager_KeysInterface_get_channel_keys,
 981                 get_secure_random_bytes: KeysManager_KeysInterface_get_secure_random_bytes,
 982                 read_chan_signer: KeysManager_KeysInterface_read_chan_signer,
 983         }
 984 }
 985 use lightning::chain::keysinterface::KeysInterface as KeysInterfaceTraitImport;
 986 #[must_use]
 987 extern "C" fn KeysManager_KeysInterface_get_node_secret(this_arg: *const c_void) -> crate::c_types::SecretKey {
 988         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_node_secret();
 989         crate::c_types::SecretKey::from_rust(ret)
 990 }
 991 #[must_use]
 992 extern "C" fn KeysManager_KeysInterface_get_destination_script(this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 993         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_destination_script();
 994         ret.into_bytes().into()
 995 }
 996 #[must_use]
 997 extern "C" fn KeysManager_KeysInterface_get_shutdown_pubkey(this_arg: *const c_void) -> crate::c_types::PublicKey {
 998         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_shutdown_pubkey();
 999         crate::c_types::PublicKey::from_rust(&ret)
1000 }
1001 #[must_use]
1002 extern "C" fn KeysManager_KeysInterface_get_channel_keys(this_arg: *const c_void, mut _inbound: bool, mut channel_value_satoshis: u64) -> crate::chain::keysinterface::ChannelKeys {
1003         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_channel_keys(_inbound, channel_value_satoshis);
1004         ret.into()
1005 }
1006 #[must_use]
1007 extern "C" fn KeysManager_KeysInterface_get_secure_random_bytes(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes {
1008         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_secure_random_bytes();
1009         crate::c_types::ThirtyTwoBytes { data: ret }
1010 }
1011 #[must_use]
1012 extern "C" fn KeysManager_KeysInterface_read_chan_signer(this_arg: *const c_void, mut reader: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChanKeySignerDecodeErrorZ {
1013         let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.read_chan_signer(reader.to_slice());
1014         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o.into() }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) };
1015         local_ret
1016 }
1017