From 96b2927a9a548509d77fba3130791ebb61dfded6 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Sep 2020 18:19:15 -0400 Subject: [PATCH] Add automatically generated C/C++ wrapper bindings --- lightning-c-bindings/include/lightning.h | 6716 +++++++++++++++++ lightning-c-bindings/include/lightningpp.hpp | 1987 +++++ lightning-c-bindings/include/rust_types.h | 154 + lightning-c-bindings/src/c_types/derived.rs | 405 + .../src/chain/chaininterface.rs | 606 ++ .../src/chain/keysinterface.rs | 938 +++ lightning-c-bindings/src/chain/mod.rs | 9 + lightning-c-bindings/src/chain/transaction.rs | 110 + lightning-c-bindings/src/lib.rs | 24 + lightning-c-bindings/src/ln/chan_utils.rs | 745 ++ lightning-c-bindings/src/ln/channelmanager.rs | 842 +++ lightning-c-bindings/src/ln/channelmonitor.rs | 550 ++ lightning-c-bindings/src/ln/features.rs | 136 + lightning-c-bindings/src/ln/mod.rs | 21 + lightning-c-bindings/src/ln/msgs.rs | 3867 ++++++++++ lightning-c-bindings/src/ln/peer_handler.rs | 406 + lightning-c-bindings/src/routing/mod.rs | 8 + .../src/routing/network_graph.rs | 795 ++ lightning-c-bindings/src/routing/router.rs | 318 + lightning-c-bindings/src/util/config.rs | 687 ++ lightning-c-bindings/src/util/errors.rs | 162 + lightning-c-bindings/src/util/events.rs | 937 +++ lightning-c-bindings/src/util/logger.rs | 121 + lightning-c-bindings/src/util/mod.rs | 11 + lightning-c-bindings/src/util/ser.rs | 7 + 25 files changed, 20562 insertions(+) create mode 100644 lightning-c-bindings/include/lightning.h create mode 100644 lightning-c-bindings/include/lightningpp.hpp create mode 100644 lightning-c-bindings/include/rust_types.h create mode 100644 lightning-c-bindings/src/c_types/derived.rs create mode 100644 lightning-c-bindings/src/chain/chaininterface.rs create mode 100644 lightning-c-bindings/src/chain/keysinterface.rs create mode 100644 lightning-c-bindings/src/chain/mod.rs create mode 100644 lightning-c-bindings/src/chain/transaction.rs create mode 100644 lightning-c-bindings/src/lib.rs create mode 100644 lightning-c-bindings/src/ln/chan_utils.rs create mode 100644 lightning-c-bindings/src/ln/channelmanager.rs create mode 100644 lightning-c-bindings/src/ln/channelmonitor.rs create mode 100644 lightning-c-bindings/src/ln/features.rs create mode 100644 lightning-c-bindings/src/ln/mod.rs create mode 100644 lightning-c-bindings/src/ln/msgs.rs create mode 100644 lightning-c-bindings/src/ln/peer_handler.rs create mode 100644 lightning-c-bindings/src/routing/mod.rs create mode 100644 lightning-c-bindings/src/routing/network_graph.rs create mode 100644 lightning-c-bindings/src/routing/router.rs create mode 100644 lightning-c-bindings/src/util/config.rs create mode 100644 lightning-c-bindings/src/util/errors.rs create mode 100644 lightning-c-bindings/src/util/events.rs create mode 100644 lightning-c-bindings/src/util/logger.rs create mode 100644 lightning-c-bindings/src/util/mod.rs create mode 100644 lightning-c-bindings/src/util/ser.rs diff --git a/lightning-c-bindings/include/lightning.h b/lightning-c-bindings/include/lightning.h new file mode 100644 index 000000000..23efa9db6 --- /dev/null +++ b/lightning-c-bindings/include/lightning.h @@ -0,0 +1,6716 @@ +/* Text to put at the beginning of the generated file. Probably a license. */ + +/* Generated with cbindgen:0.14.4 */ + +/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */ + +#include +#include +#include +#include + +/** + * Used to give chain error details upstream + */ +typedef enum LDKChainError { + /** + * Client doesn't support UTXO lookup (but the chain hash matches our genesis block hash) + */ + LDKChainError_NotSupported, + /** + * Chain isn't the one watched + */ + LDKChainError_NotWatched, + /** + * Tx doesn't exist or is unconfirmed + */ + LDKChainError_UnknownTx, + /** + * Must be last for serialization purposes + */ + LDKChainError_Sentinel, +} LDKChainError; + +/** + * An error enum representing a failure to persist a channel monitor update. + */ +typedef enum LDKChannelMonitorUpdateErr { + /** + * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of + * our state failed, but is expected to succeed at some point in the future). + * + * Such a failure will \"freeze\" a channel, preventing us from revoking old states or + * submitting new commitment transactions to the remote party. Once the update(s) which failed + * have been successfully applied, ChannelManager::channel_monitor_updated can be used to + * restore the channel to an operational state. + * + * Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If + * you return a TemporaryFailure you must ensure that it is written to disk safely before + * writing out the latest ChannelManager state. + * + * Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur + * (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting + * to claim it on this channel) and those updates must be applied wherever they can be. At + * least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should + * be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to + * the channel which would invalidate previous ChannelMonitors are not made when a channel has + * been \"frozen\". + * + * Note that even if updates made after TemporaryFailure succeed you must still call + * channel_monitor_updated to ensure you have the latest monitor and re-enable normal channel + * operation. + * + * Note that the update being processed here will not be replayed for you when you call + * ChannelManager::channel_monitor_updated, so you must store the update itself along + * with the persisted ChannelMonitor on your own local disk prior to returning a + * TemporaryFailure. You may, of course, employ a journaling approach, storing only the + * ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at + * reload-time. + * + * For deployments where a copy of ChannelMonitors and other local state are backed up in a + * remote location (with local copies persisted immediately), it is anticipated that all + * updates will return TemporaryFailure until the remote copies could be updated. + */ + LDKChannelMonitorUpdateErr_TemporaryFailure, + /** + * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a + * different watchtower and cannot update with all watchtowers that were previously informed + * of this channel). This will force-close the channel in question (which will generate one + * final ChannelMonitorUpdate which must be delivered to at least one ChannelMonitor copy). + * + * Should also be used to indicate a failure to update the local persisted copy of the channel + * monitor. + */ + LDKChannelMonitorUpdateErr_PermanentFailure, + /** + * Must be last for serialization purposes + */ + LDKChannelMonitorUpdateErr_Sentinel, +} LDKChannelMonitorUpdateErr; + +/** + * An enum that represents the speed at which we want a transaction to confirm used for feerate + * estimation. + */ +typedef enum LDKConfirmationTarget { + /** + * We are happy with this transaction confirming slowly when feerate drops some. + */ + LDKConfirmationTarget_Background, + /** + * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine. + */ + LDKConfirmationTarget_Normal, + /** + * We'd like this transaction to confirm in the next few blocks. + */ + LDKConfirmationTarget_HighPriority, + /** + * Must be last for serialization purposes + */ + LDKConfirmationTarget_Sentinel, +} LDKConfirmationTarget; + +/** + * An enum representing the available verbosity levels of the logger. + */ +typedef enum LDKLevel { + /** + *Designates logger being silent + */ + LDKLevel_Off, + /** + * Designates very serious errors + */ + LDKLevel_Error, + /** + * Designates hazardous situations + */ + LDKLevel_Warn, + /** + * Designates useful information + */ + LDKLevel_Info, + /** + * Designates lower priority information + */ + LDKLevel_Debug, + /** + * Designates very low priority, often extremely verbose, information + */ + LDKLevel_Trace, + /** + * Must be last for serialization purposes + */ + LDKLevel_Sentinel, +} LDKLevel; + +typedef enum LDKNetwork { + LDKNetwork_Bitcoin, + LDKNetwork_Testnet, + LDKNetwork_Regtest, + /** + * Must be last for serialization purposes + */ + LDKNetwork_Sentinel, +} LDKNetwork; + +typedef enum LDKSecp256k1Error { + LDKSecp256k1Error_IncorrectSignature, + LDKSecp256k1Error_InvalidMessage, + LDKSecp256k1Error_InvalidPublicKey, + LDKSecp256k1Error_InvalidSignature, + LDKSecp256k1Error_InvalidSecretKey, + LDKSecp256k1Error_InvalidRecoveryId, + LDKSecp256k1Error_InvalidTweak, + LDKSecp256k1Error_NotEnoughMemory, + LDKSecp256k1Error_CallbackPanicked, + /** + * Must be last for serialization purposes + */ + LDKSecp256k1Error_Sentinel, +} LDKSecp256k1Error; + +typedef struct LDKCVecTempl_u8 { + uint8_t *data; + uintptr_t datalen; +} LDKCVecTempl_u8; + +typedef LDKCVecTempl_u8 LDKCVec_u8Z; + +/** + * A transaction output including a scriptPubKey and value. + * This type *does* own its own memory, so must be free'd appropriately. + */ +typedef struct LDKTxOut { + LDKCVec_u8Z script_pubkey; + uint64_t value; +} LDKTxOut; + +/** + * Arbitrary 32 bytes, which could represent one of a few different things. You probably want to + * look up the corresponding function in rust-lightning's docs. + */ +typedef struct LDKThirtyTwoBytes { + uint8_t data[32]; +} LDKThirtyTwoBytes; + +typedef struct LDKC2TupleTempl_ThirtyTwoBytes__u32 { + LDKThirtyTwoBytes *a; + uint32_t *b; +} LDKC2TupleTempl_ThirtyTwoBytes__u32; + +typedef LDKC2TupleTempl_ThirtyTwoBytes__u32 LDKC2Tuple_Txidu32Z; + +typedef struct LDKC2TupleTempl_CVec_u8Z__u64 { + LDKCVec_u8Z *a; + uint64_t *b; +} LDKC2TupleTempl_CVec_u8Z__u64; + +typedef LDKC2TupleTempl_CVec_u8Z__u64 LDKC2Tuple_Scriptu64Z; + +typedef struct LDKC2TupleTempl_u64__u64 { + uint64_t *a; + uint64_t *b; +} LDKC2TupleTempl_u64__u64; + +typedef LDKC2TupleTempl_u64__u64 LDKC2Tuple_u64u64Z; + +typedef struct LDKSignature { + uint8_t compact_form[64]; +} LDKSignature; + +typedef struct LDKCVecTempl_Signature { + LDKSignature *data; + uintptr_t datalen; +} LDKCVecTempl_Signature; + +typedef struct LDKC2TupleTempl_Signature__CVecTempl_Signature { + LDKSignature *a; + LDKCVecTempl_Signature *b; +} LDKC2TupleTempl_Signature__CVecTempl_Signature; + +typedef LDKC2TupleTempl_Signature__CVecTempl_Signature LDKC2Tuple_SignatureCVec_SignatureZZ; + +typedef LDKCVecTempl_Signature LDKCVec_SignatureZ; + +typedef union LDKCResultPtr_C2TupleTempl_Signature__CVecTempl_Signature________u8 { + LDKC2TupleTempl_Signature__CVecTempl_Signature *result; + uint8_t *err; +} LDKCResultPtr_C2TupleTempl_Signature__CVecTempl_Signature________u8; + +typedef struct LDKCResultTempl_C2TupleTempl_Signature__CVecTempl_Signature________u8 { + LDKCResultPtr_C2TupleTempl_Signature__CVecTempl_Signature________u8 contents; + bool result_ok; +} LDKCResultTempl_C2TupleTempl_Signature__CVecTempl_Signature________u8; + +typedef LDKCResultTempl_C2TupleTempl_Signature__CVecTempl_Signature________u8 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ; + +typedef union LDKCResultPtr_Signature__u8 { + LDKSignature *result; + uint8_t *err; +} LDKCResultPtr_Signature__u8; + +typedef struct LDKCResultTempl_Signature__u8 { + LDKCResultPtr_Signature__u8 contents; + bool result_ok; +} LDKCResultTempl_Signature__u8; + +typedef LDKCResultTempl_Signature__u8 LDKCResult_SignatureNoneZ; + +typedef union LDKCResultPtr_CVecTempl_Signature_____u8 { + LDKCVecTempl_Signature *result; + uint8_t *err; +} LDKCResultPtr_CVecTempl_Signature_____u8; + +typedef struct LDKCResultTempl_CVecTempl_Signature_____u8 { + LDKCResultPtr_CVecTempl_Signature_____u8 contents; + bool result_ok; +} LDKCResultTempl_CVecTempl_Signature_____u8; + +typedef LDKCResultTempl_CVecTempl_Signature_____u8 LDKCResult_CVec_SignatureZNoneZ; + +/** + * A Rust str object, ie a reference to a UTF8-valid string. + * This is *not* null-terminated so cannot be used directly as a C string! + */ +typedef struct LDKStr { + const uint8_t *chars; + uintptr_t len; +} LDKStr; + +/** + * Indicates an error on the client's part (usually some variant of attempting to use too-low or + * too-high values) + */ +typedef enum LDKAPIError_Tag { + /** + * Indicates the API was wholly misused (see err for more). Cases where these can be returned + * are documented, but generally indicates some precondition of a function was violated. + */ + LDKAPIError_APIMisuseError, + /** + * Due to a high feerate, we were unable to complete the request. + * For example, this may be returned if the feerate implies we cannot open a channel at the + * requested value, but opening a larger channel would succeed. + */ + LDKAPIError_FeeRateTooHigh, + /** + * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route, + * too-many-hops, etc). + */ + LDKAPIError_RouteError, + /** + * We were unable to complete the request as the Channel required to do so is unable to + * complete the request (or was not found). This can take many forms, including disconnected + * peer, channel at capacity, channel shutting down, etc. + */ + LDKAPIError_ChannelUnavailable, + /** + * An attempt to call add/update_monitor returned an Err (ie you did this!), causing the + * attempted action to fail. + */ + LDKAPIError_MonitorUpdateFailed, + /** + * Must be last for serialization purposes + */ + LDKAPIError_Sentinel, +} LDKAPIError_Tag; + +typedef struct LDKAPIError_LDKAPIMisuseError_Body { + LDKCVec_u8Z err; +} LDKAPIError_LDKAPIMisuseError_Body; + +typedef struct LDKAPIError_LDKFeeRateTooHigh_Body { + LDKCVec_u8Z err; + uint32_t feerate; +} LDKAPIError_LDKFeeRateTooHigh_Body; + +typedef struct LDKAPIError_LDKRouteError_Body { + LDKStr err; +} LDKAPIError_LDKRouteError_Body; + +typedef struct LDKAPIError_LDKChannelUnavailable_Body { + LDKCVec_u8Z err; +} LDKAPIError_LDKChannelUnavailable_Body; + +typedef struct LDKAPIError { + LDKAPIError_Tag tag; + union { + LDKAPIError_LDKAPIMisuseError_Body api_misuse_error; + LDKAPIError_LDKFeeRateTooHigh_Body fee_rate_too_high; + LDKAPIError_LDKRouteError_Body route_error; + LDKAPIError_LDKChannelUnavailable_Body channel_unavailable; + }; +} LDKAPIError; + +typedef union LDKCResultPtr_u8__APIError { + uint8_t *result; + LDKAPIError *err; +} LDKCResultPtr_u8__APIError; + +typedef struct LDKCResultTempl_u8__APIError { + LDKCResultPtr_u8__APIError contents; + bool result_ok; +} LDKCResultTempl_u8__APIError; + +typedef LDKCResultTempl_u8__APIError LDKCResult_NoneAPIErrorZ; + + + +/** + * If a payment fails to send, it can be in one of several states. This enum is returned as the + * Err() type describing which state the payment is in, see the description of individual enum + * states for more. + */ +typedef struct MUST_USE_STRUCT LDKPaymentSendFailure { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePaymentSendFailure *inner; + bool is_owned; +} LDKPaymentSendFailure; + +typedef union LDKCResultPtr_u8__PaymentSendFailure { + uint8_t *result; + LDKPaymentSendFailure *err; +} LDKCResultPtr_u8__PaymentSendFailure; + +typedef struct LDKCResultTempl_u8__PaymentSendFailure { + LDKCResultPtr_u8__PaymentSendFailure contents; + bool result_ok; +} LDKCResultTempl_u8__PaymentSendFailure; + +typedef LDKCResultTempl_u8__PaymentSendFailure LDKCResult_NonePaymentSendFailureZ; + +typedef union LDKCResultPtr_u8__ChannelMonitorUpdateErr { + uint8_t *result; + LDKChannelMonitorUpdateErr *err; +} LDKCResultPtr_u8__ChannelMonitorUpdateErr; + +typedef struct LDKCResultTempl_u8__ChannelMonitorUpdateErr { + LDKCResultPtr_u8__ChannelMonitorUpdateErr contents; + bool result_ok; +} LDKCResultTempl_u8__ChannelMonitorUpdateErr; + +typedef LDKCResultTempl_u8__ChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ; + + + +/** + * General Err type for ChannelMonitor actions. Generally, this implies that the data provided is + * inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this + * means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was + * corrupted. + * Contains a human-readable error message. + */ +typedef struct MUST_USE_STRUCT LDKMonitorUpdateError { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeMonitorUpdateError *inner; + bool is_owned; +} LDKMonitorUpdateError; + +typedef union LDKCResultPtr_u8__MonitorUpdateError { + uint8_t *result; + LDKMonitorUpdateError *err; +} LDKCResultPtr_u8__MonitorUpdateError; + +typedef struct LDKCResultTempl_u8__MonitorUpdateError { + LDKCResultPtr_u8__MonitorUpdateError contents; + bool result_ok; +} LDKCResultTempl_u8__MonitorUpdateError; + +typedef LDKCResultTempl_u8__MonitorUpdateError LDKCResult_NoneMonitorUpdateErrorZ; + + + +/** + * A reference to a transaction output. + * + * Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32 + * due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way. + */ +typedef struct MUST_USE_STRUCT LDKOutPoint { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeOutPoint *inner; + bool is_owned; +} LDKOutPoint; + +typedef struct LDKC2TupleTempl_OutPoint__CVec_u8Z { + LDKOutPoint *a; + LDKCVec_u8Z *b; +} LDKC2TupleTempl_OutPoint__CVec_u8Z; + +typedef LDKC2TupleTempl_OutPoint__CVec_u8Z LDKC2Tuple_OutPointScriptZ; + + + +/** + * A channel_announcement message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKChannelAnnouncement { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelAnnouncement *inner; + bool is_owned; +} LDKChannelAnnouncement; + + + +/** + * A channel_update message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKChannelUpdate { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelUpdate *inner; + bool is_owned; +} LDKChannelUpdate; + +typedef struct LDKC3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate { + LDKChannelAnnouncement *a; + LDKChannelUpdate *b; + LDKChannelUpdate *c; +} LDKC3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate; + +typedef LDKC3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ; + + + +/** + * Error for PeerManager errors. If you get one of these, you must disconnect the socket and + * generate no further read_event/write_buffer_space_avail calls for the descriptor, only + * triggering a single socket_disconnected call (unless it was provided in response to a + * new_*_connection event, in which case no such socket_disconnected() must be called and the + * socket silently disconencted). + */ +typedef struct MUST_USE_STRUCT LDKPeerHandleError { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePeerHandleError *inner; + bool is_owned; +} LDKPeerHandleError; + +typedef union LDKCResultPtr_u8__PeerHandleError { + uint8_t *result; + LDKPeerHandleError *err; +} LDKCResultPtr_u8__PeerHandleError; + +typedef struct LDKCResultTempl_u8__PeerHandleError { + LDKCResultPtr_u8__PeerHandleError contents; + bool result_ok; +} LDKCResultTempl_u8__PeerHandleError; + +typedef LDKCResultTempl_u8__PeerHandleError LDKCResult_NonePeerHandleErrorZ; + + + +/** + * Information about an HTLC as it appears in a commitment transaction + */ +typedef struct MUST_USE_STRUCT LDKHTLCOutputInCommitment { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeHTLCOutputInCommitment *inner; + bool is_owned; +} LDKHTLCOutputInCommitment; + +typedef struct LDKC2TupleTempl_HTLCOutputInCommitment__Signature { + LDKHTLCOutputInCommitment *a; + LDKSignature *b; +} LDKC2TupleTempl_HTLCOutputInCommitment__Signature; + +typedef LDKC2TupleTempl_HTLCOutputInCommitment__Signature LDKC2Tuple_HTLCOutputInCommitmentSignatureZ; + +typedef struct LDKPublicKey { + uint8_t compressed_form[33]; +} LDKPublicKey; + +/** + * When on-chain outputs are created by rust-lightning (which our counterparty is not able to + * claim at any point in the future) an event is generated which you must track and be able to + * spend on-chain. The information needed to do this is provided in this enum, including the + * outpoint describing which txid and output index is available, the full output which exists at + * that txid/index, and any keys or other information required to sign. + */ +typedef enum LDKSpendableOutputDescriptor_Tag { + /** + * An output to a script which was provided via KeysInterface, thus you should already know + * how to spend it. No keys are provided as rust-lightning was never given any keys - only the + * script_pubkey as it appears in the output. + * These may include outputs from a transaction punishing our counterparty or claiming an HTLC + * on-chain using the payment preimage or after it has timed out. + */ + LDKSpendableOutputDescriptor_StaticOutput, + /** + * An output to a P2WSH script which can be spent with a single signature after a CSV delay. + * + * The witness in the spending input should be: + * (MINIMALIF standard rule) + * + * Note that the nSequence field in the spending input must be set to to_self_delay + * (which means the transaction is not broadcastable until at least to_self_delay + * blocks after the outpoint confirms). + * + * These are generally the result of a \"revocable\" output to us, spendable only by us unless + * it is an output from an old state which we broadcast (which should never happen). + * + * To derive the delayed_payment key which is used to sign for this input, you must pass the + * local delayed_payment_base_key (ie the private key which corresponds to the pubkey in + * ChannelKeys::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to + * chan_utils::derive_private_key. The public key can be generated without the secret key + * using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in + * ChannelKeys::pubkeys(). + * + * To derive the remote_revocation_pubkey provided here (which is used in the witness + * script generation), you must pass the remote revocation_basepoint (which appears in the + * call to ChannelKeys::on_accept) and the provided per_commitment point + * to chan_utils::derive_public_revocation_key. + * + * The witness script which is hashed and included in the output script_pubkey may be + * regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey + * (derived as above), and the to_self_delay contained here to + * chan_utils::get_revokeable_redeemscript. + */ + LDKSpendableOutputDescriptor_DynamicOutputP2WSH, + /** + * An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which + * corresponds to the public key in ChannelKeys::pubkeys().payment_point). + * The witness in the spending input, is, thus, simply: + * + * + * These are generally the result of our counterparty having broadcast the current state, + * allowing us to claim the non-HTLC-encumbered outputs immediately. + */ + LDKSpendableOutputDescriptor_StaticOutputRemotePayment, + /** + * Must be last for serialization purposes + */ + LDKSpendableOutputDescriptor_Sentinel, +} LDKSpendableOutputDescriptor_Tag; + +typedef struct LDKSpendableOutputDescriptor_LDKStaticOutput_Body { + LDKOutPoint outpoint; + LDKTxOut output; +} LDKSpendableOutputDescriptor_LDKStaticOutput_Body; + +typedef struct LDKSpendableOutputDescriptor_LDKDynamicOutputP2WSH_Body { + LDKOutPoint outpoint; + LDKPublicKey per_commitment_point; + uint16_t to_self_delay; + LDKTxOut output; + LDKC2Tuple_u64u64Z key_derivation_params; + LDKPublicKey remote_revocation_pubkey; +} LDKSpendableOutputDescriptor_LDKDynamicOutputP2WSH_Body; + +typedef struct LDKSpendableOutputDescriptor_LDKStaticOutputRemotePayment_Body { + LDKOutPoint outpoint; + LDKTxOut output; + LDKC2Tuple_u64u64Z key_derivation_params; +} LDKSpendableOutputDescriptor_LDKStaticOutputRemotePayment_Body; + +typedef struct LDKSpendableOutputDescriptor { + LDKSpendableOutputDescriptor_Tag tag; + union { + LDKSpendableOutputDescriptor_LDKStaticOutput_Body static_output; + LDKSpendableOutputDescriptor_LDKDynamicOutputP2WSH_Body dynamic_output_p2wsh; + LDKSpendableOutputDescriptor_LDKStaticOutputRemotePayment_Body static_output_remote_payment; + }; +} LDKSpendableOutputDescriptor; + +typedef struct LDKCVecTempl_SpendableOutputDescriptor { + LDKSpendableOutputDescriptor *data; + uintptr_t datalen; +} LDKCVecTempl_SpendableOutputDescriptor; + +typedef LDKCVecTempl_SpendableOutputDescriptor LDKCVec_SpendableOutputDescriptorZ; + +/** + * An Event which you should probably take some action in response to. + * + * Note that while Writeable and Readable are implemented for Event, you probably shouldn't use + * them directly as they don't round-trip exactly (for example FundingGenerationReady is never + * written as it makes no sense to respond to it after reconnecting to peers). + */ +typedef enum LDKEvent_Tag { + /** + * Used to indicate that the client should generate a funding transaction with the given + * parameters and then call ChannelManager::funding_transaction_generated. + * Generated in ChannelManager message handling. + * Note that *all inputs* in the funding transaction must spend SegWit outputs or your + * counterparty can steal your funds! + */ + LDKEvent_FundingGenerationReady, + /** + * Used to indicate that the client may now broadcast the funding transaction it created for a + * channel. Broadcasting such a transaction prior to this event may lead to our counterparty + * trivially stealing all funds in the funding transaction! + */ + LDKEvent_FundingBroadcastSafe, + /** + * Indicates we've received money! Just gotta dig out that payment preimage and feed it to + * ChannelManager::claim_funds to get it.... + * Note that if the preimage is not known or the amount paid is incorrect, you should call + * ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid + * network congestion. + * The amount paid should be considered 'incorrect' when it is less than or more than twice + * the amount expected. + * If you fail to call either ChannelManager::claim_funds or + * ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be + * automatically failed. + */ + LDKEvent_PaymentReceived, + /** + * Indicates an outbound payment we made succeeded (ie it made it all the way to its target + * and we got back the payment preimage for it). + * Note that duplicative PaymentSent Events may be generated - it is your responsibility to + * deduplicate them by payment_preimage (which MUST be unique)! + */ + LDKEvent_PaymentSent, + /** + * Indicates an outbound payment we made failed. Probably some intermediary node dropped + * something. You may wish to retry with a different route. + * Note that duplicative PaymentFailed Events may be generated - it is your responsibility to + * deduplicate them by payment_hash (which MUST be unique)! + */ + LDKEvent_PaymentFailed, + /** + * Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a + * time in the future. + */ + LDKEvent_PendingHTLCsForwardable, + /** + * Used to indicate that an output was generated on-chain which you should know how to spend. + * Such an output will *not* ever be spent by rust-lightning, and are not at risk of your + * counterparty spending them due to some kind of timeout. Thus, you need to store them + * somewhere and spend them when you create on-chain transactions. + */ + LDKEvent_SpendableOutputs, + /** + * Must be last for serialization purposes + */ + LDKEvent_Sentinel, +} LDKEvent_Tag; + +typedef struct LDKEvent_LDKFundingGenerationReady_Body { + LDKThirtyTwoBytes temporary_channel_id; + uint64_t channel_value_satoshis; + LDKCVec_u8Z output_script; + uint64_t user_channel_id; +} LDKEvent_LDKFundingGenerationReady_Body; + +typedef struct LDKEvent_LDKFundingBroadcastSafe_Body { + LDKOutPoint funding_txo; + uint64_t user_channel_id; +} LDKEvent_LDKFundingBroadcastSafe_Body; + +typedef struct LDKEvent_LDKPaymentReceived_Body { + LDKThirtyTwoBytes payment_hash; + LDKThirtyTwoBytes payment_secret; + uint64_t amt; +} LDKEvent_LDKPaymentReceived_Body; + +typedef struct LDKEvent_LDKPaymentSent_Body { + LDKThirtyTwoBytes payment_preimage; +} LDKEvent_LDKPaymentSent_Body; + +typedef struct LDKEvent_LDKPaymentFailed_Body { + LDKThirtyTwoBytes payment_hash; + bool rejected_by_dest; +} LDKEvent_LDKPaymentFailed_Body; + +typedef struct LDKEvent_LDKPendingHTLCsForwardable_Body { + uint64_t time_forwardable; +} LDKEvent_LDKPendingHTLCsForwardable_Body; + +typedef struct LDKEvent_LDKSpendableOutputs_Body { + LDKCVec_SpendableOutputDescriptorZ outputs; +} LDKEvent_LDKSpendableOutputs_Body; + +typedef struct LDKEvent { + LDKEvent_Tag tag; + union { + LDKEvent_LDKFundingGenerationReady_Body funding_generation_ready; + LDKEvent_LDKFundingBroadcastSafe_Body funding_broadcast_safe; + LDKEvent_LDKPaymentReceived_Body payment_received; + LDKEvent_LDKPaymentSent_Body payment_sent; + LDKEvent_LDKPaymentFailed_Body payment_failed; + LDKEvent_LDKPendingHTLCsForwardable_Body pending_htl_cs_forwardable; + LDKEvent_LDKSpendableOutputs_Body spendable_outputs; + }; +} LDKEvent; + + + +/** + * An accept_channel message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKAcceptChannel { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeAcceptChannel *inner; + bool is_owned; +} LDKAcceptChannel; + + + +/** + * An open_channel message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKOpenChannel { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeOpenChannel *inner; + bool is_owned; +} LDKOpenChannel; + + + +/** + * A funding_created message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKFundingCreated { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeFundingCreated *inner; + bool is_owned; +} LDKFundingCreated; + + + +/** + * A funding_signed message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKFundingSigned { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeFundingSigned *inner; + bool is_owned; +} LDKFundingSigned; + + + +/** + * A funding_locked message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKFundingLocked { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeFundingLocked *inner; + bool is_owned; +} LDKFundingLocked; + + + +/** + * An announcement_signatures message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKAnnouncementSignatures { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeAnnouncementSignatures *inner; + bool is_owned; +} LDKAnnouncementSignatures; + + + +/** + * Struct used to return values from revoke_and_ack messages, containing a bunch of commitment + * transaction updates if they were pending. + */ +typedef struct MUST_USE_STRUCT LDKCommitmentUpdate { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeCommitmentUpdate *inner; + bool is_owned; +} LDKCommitmentUpdate; + + + +/** + * A revoke_and_ack message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKRevokeAndACK { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeRevokeAndACK *inner; + bool is_owned; +} LDKRevokeAndACK; + + + +/** + * A closing_signed message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKClosingSigned { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeClosingSigned *inner; + bool is_owned; +} LDKClosingSigned; + + + +/** + * A shutdown message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKShutdown { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeShutdown *inner; + bool is_owned; +} LDKShutdown; + + + +/** + * A channel_reestablish message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKChannelReestablish { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelReestablish *inner; + bool is_owned; +} LDKChannelReestablish; + + + +/** + * A node_announcement message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKNodeAnnouncement { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNodeAnnouncement *inner; + bool is_owned; +} LDKNodeAnnouncement; + + + +/** + * An error message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKErrorMessage { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeErrorMessage *inner; + bool is_owned; +} LDKErrorMessage; + +/** + * Used to put an error message in a LightningError + */ +typedef enum LDKErrorAction_Tag { + /** + * The peer took some action which made us think they were useless. Disconnect them. + */ + LDKErrorAction_DisconnectPeer, + /** + * The peer did something harmless that we weren't able to process, just log and ignore + */ + LDKErrorAction_IgnoreError, + /** + * The peer did something incorrect. Tell them. + */ + LDKErrorAction_SendErrorMessage, + /** + * Must be last for serialization purposes + */ + LDKErrorAction_Sentinel, +} LDKErrorAction_Tag; + +typedef struct LDKErrorAction_LDKDisconnectPeer_Body { + LDKErrorMessage msg; +} LDKErrorAction_LDKDisconnectPeer_Body; + +typedef struct LDKErrorAction_LDKSendErrorMessage_Body { + LDKErrorMessage msg; +} LDKErrorAction_LDKSendErrorMessage_Body; + +typedef struct LDKErrorAction { + LDKErrorAction_Tag tag; + union { + LDKErrorAction_LDKDisconnectPeer_Body disconnect_peer; + LDKErrorAction_LDKSendErrorMessage_Body send_error_message; + }; +} LDKErrorAction; + +/** + * The information we received from a peer along the route of a payment we originated. This is + * returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into + * RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map. + */ +typedef enum LDKHTLCFailChannelUpdate_Tag { + /** + * We received an error which included a full ChannelUpdate message. + */ + LDKHTLCFailChannelUpdate_ChannelUpdateMessage, + /** + * We received an error which indicated only that a channel has been closed + */ + LDKHTLCFailChannelUpdate_ChannelClosed, + /** + * We received an error which indicated only that a node has failed + */ + LDKHTLCFailChannelUpdate_NodeFailure, + /** + * Must be last for serialization purposes + */ + LDKHTLCFailChannelUpdate_Sentinel, +} LDKHTLCFailChannelUpdate_Tag; + +typedef struct LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body { + LDKChannelUpdate msg; +} LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body; + +typedef struct LDKHTLCFailChannelUpdate_LDKChannelClosed_Body { + uint64_t short_channel_id; + bool is_permanent; +} LDKHTLCFailChannelUpdate_LDKChannelClosed_Body; + +typedef struct LDKHTLCFailChannelUpdate_LDKNodeFailure_Body { + LDKPublicKey node_id; + bool is_permanent; +} LDKHTLCFailChannelUpdate_LDKNodeFailure_Body; + +typedef struct LDKHTLCFailChannelUpdate { + LDKHTLCFailChannelUpdate_Tag tag; + union { + LDKHTLCFailChannelUpdate_LDKChannelUpdateMessage_Body channel_update_message; + LDKHTLCFailChannelUpdate_LDKChannelClosed_Body channel_closed; + LDKHTLCFailChannelUpdate_LDKNodeFailure_Body node_failure; + }; +} LDKHTLCFailChannelUpdate; + +/** + * An event generated by ChannelManager which indicates a message should be sent to a peer (or + * broadcast to most peers). + * These events are handled by PeerManager::process_events if you are using a PeerManager. + */ +typedef enum LDKMessageSendEvent_Tag { + /** + * Used to indicate that we've accepted a channel open and should send the accept_channel + * message provided to the given peer. + */ + LDKMessageSendEvent_SendAcceptChannel, + /** + * Used to indicate that we've initiated a channel open and should send the open_channel + * message provided to the given peer. + */ + LDKMessageSendEvent_SendOpenChannel, + /** + * Used to indicate that a funding_created message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendFundingCreated, + /** + * Used to indicate that a funding_signed message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendFundingSigned, + /** + * Used to indicate that a funding_locked message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendFundingLocked, + /** + * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendAnnouncementSignatures, + /** + * Used to indicate that a series of HTLC update messages, as well as a commitment_signed + * message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_UpdateHTLCs, + /** + * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendRevokeAndACK, + /** + * Used to indicate that a closing_signed message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendClosingSigned, + /** + * Used to indicate that a shutdown message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendShutdown, + /** + * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id. + */ + LDKMessageSendEvent_SendChannelReestablish, + /** + * Used to indicate that a channel_announcement and channel_update should be broadcast to all + * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2). + * + * Note that after doing so, you very likely (unless you did so very recently) want to call + * ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event. + * This ensures that any nodes which see our channel_announcement also have a relevant + * node_announcement, including relevant feature flags which may be important for routing + * through or to us. + */ + LDKMessageSendEvent_BroadcastChannelAnnouncement, + /** + * Used to indicate that a node_announcement should be broadcast to all peers. + */ + LDKMessageSendEvent_BroadcastNodeAnnouncement, + /** + * Used to indicate that a channel_update should be broadcast to all peers. + */ + LDKMessageSendEvent_BroadcastChannelUpdate, + /** + * Broadcast an error downstream to be handled + */ + LDKMessageSendEvent_HandleError, + /** + * When a payment fails we may receive updates back from the hop where it failed. In such + * cases this event is generated so that we can inform the network graph of this information. + */ + LDKMessageSendEvent_PaymentFailureNetworkUpdate, + /** + * Must be last for serialization purposes + */ + LDKMessageSendEvent_Sentinel, +} LDKMessageSendEvent_Tag; + +typedef struct LDKMessageSendEvent_LDKSendAcceptChannel_Body { + LDKPublicKey node_id; + LDKAcceptChannel msg; +} LDKMessageSendEvent_LDKSendAcceptChannel_Body; + +typedef struct LDKMessageSendEvent_LDKSendOpenChannel_Body { + LDKPublicKey node_id; + LDKOpenChannel msg; +} LDKMessageSendEvent_LDKSendOpenChannel_Body; + +typedef struct LDKMessageSendEvent_LDKSendFundingCreated_Body { + LDKPublicKey node_id; + LDKFundingCreated msg; +} LDKMessageSendEvent_LDKSendFundingCreated_Body; + +typedef struct LDKMessageSendEvent_LDKSendFundingSigned_Body { + LDKPublicKey node_id; + LDKFundingSigned msg; +} LDKMessageSendEvent_LDKSendFundingSigned_Body; + +typedef struct LDKMessageSendEvent_LDKSendFundingLocked_Body { + LDKPublicKey node_id; + LDKFundingLocked msg; +} LDKMessageSendEvent_LDKSendFundingLocked_Body; + +typedef struct LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body { + LDKPublicKey node_id; + LDKAnnouncementSignatures msg; +} LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body; + +typedef struct LDKMessageSendEvent_LDKUpdateHTLCs_Body { + LDKPublicKey node_id; + LDKCommitmentUpdate updates; +} LDKMessageSendEvent_LDKUpdateHTLCs_Body; + +typedef struct LDKMessageSendEvent_LDKSendRevokeAndACK_Body { + LDKPublicKey node_id; + LDKRevokeAndACK msg; +} LDKMessageSendEvent_LDKSendRevokeAndACK_Body; + +typedef struct LDKMessageSendEvent_LDKSendClosingSigned_Body { + LDKPublicKey node_id; + LDKClosingSigned msg; +} LDKMessageSendEvent_LDKSendClosingSigned_Body; + +typedef struct LDKMessageSendEvent_LDKSendShutdown_Body { + LDKPublicKey node_id; + LDKShutdown msg; +} LDKMessageSendEvent_LDKSendShutdown_Body; + +typedef struct LDKMessageSendEvent_LDKSendChannelReestablish_Body { + LDKPublicKey node_id; + LDKChannelReestablish msg; +} LDKMessageSendEvent_LDKSendChannelReestablish_Body; + +typedef struct LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body { + LDKChannelAnnouncement msg; + LDKChannelUpdate update_msg; +} LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body; + +typedef struct LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body { + LDKNodeAnnouncement msg; +} LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body; + +typedef struct LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body { + LDKChannelUpdate msg; +} LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body; + +typedef struct LDKMessageSendEvent_LDKHandleError_Body { + LDKPublicKey node_id; + LDKErrorAction action; +} LDKMessageSendEvent_LDKHandleError_Body; + +typedef struct LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body { + LDKHTLCFailChannelUpdate update; +} LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body; + +typedef struct LDKMessageSendEvent { + LDKMessageSendEvent_Tag tag; + union { + LDKMessageSendEvent_LDKSendAcceptChannel_Body send_accept_channel; + LDKMessageSendEvent_LDKSendOpenChannel_Body send_open_channel; + LDKMessageSendEvent_LDKSendFundingCreated_Body send_funding_created; + LDKMessageSendEvent_LDKSendFundingSigned_Body send_funding_signed; + LDKMessageSendEvent_LDKSendFundingLocked_Body send_funding_locked; + LDKMessageSendEvent_LDKSendAnnouncementSignatures_Body send_announcement_signatures; + LDKMessageSendEvent_LDKUpdateHTLCs_Body update_htl_cs; + LDKMessageSendEvent_LDKSendRevokeAndACK_Body send_revoke_and_ack; + LDKMessageSendEvent_LDKSendClosingSigned_Body send_closing_signed; + LDKMessageSendEvent_LDKSendShutdown_Body send_shutdown; + LDKMessageSendEvent_LDKSendChannelReestablish_Body send_channel_reestablish; + LDKMessageSendEvent_LDKBroadcastChannelAnnouncement_Body broadcast_channel_announcement; + LDKMessageSendEvent_LDKBroadcastNodeAnnouncement_Body broadcast_node_announcement; + LDKMessageSendEvent_LDKBroadcastChannelUpdate_Body broadcast_channel_update; + LDKMessageSendEvent_LDKHandleError_Body handle_error; + LDKMessageSendEvent_LDKPaymentFailureNetworkUpdate_Body payment_failure_network_update; + }; +} LDKMessageSendEvent; + +typedef struct LDKCVecTempl_MessageSendEvent { + LDKMessageSendEvent *data; + uintptr_t datalen; +} LDKCVecTempl_MessageSendEvent; + +typedef LDKCVecTempl_MessageSendEvent LDKCVec_MessageSendEventZ; + +/** + * A trait indicating an object may generate message send events + */ +typedef struct LDKMessageSendEventsProvider { + void *this_arg; + /** + * Gets the list of pending events which were generated by previous actions, clearing the list + * in the process. + */ + LDKCVec_MessageSendEventZ (*get_and_clear_pending_msg_events)(const void *this_arg); + void (*free)(void *this_arg); +} LDKMessageSendEventsProvider; + +typedef struct LDKCVecTempl_Event { + LDKEvent *data; + uintptr_t datalen; +} LDKCVecTempl_Event; + +typedef LDKCVecTempl_Event LDKCVec_EventZ; + +/** + * A trait indicating an object may generate events + */ +typedef struct LDKEventsProvider { + void *this_arg; + /** + * Gets the list of pending events which were generated by previous actions, clearing the list + * in the process. + */ + LDKCVec_EventZ (*get_and_clear_pending_events)(const void *this_arg); + void (*free)(void *this_arg); +} LDKEventsProvider; + +/** + * A trait encapsulating the operations required of a logger + */ +typedef struct LDKLogger { + void *this_arg; + /** + * Logs the `Record` + */ + void (*log)(const void *this_arg, const char *record); + void (*free)(void *this_arg); +} LDKLogger; + + + +/** + * Configuration we set when applicable. + * + * Default::default() provides sane defaults. + */ +typedef struct MUST_USE_STRUCT LDKChannelHandshakeConfig { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelHandshakeConfig *inner; + bool is_owned; +} LDKChannelHandshakeConfig; + + + +/** + * Optional channel limits which are applied during channel creation. + * + * These limits are only applied to our counterparty's limits, not our own. + * + * Use 0/::max_value() as appropriate to skip checking. + * + * Provides sane defaults for most configurations. + * + * Most additional limits are disabled except those with which specify a default in individual + * field documentation. Note that this may result in barely-usable channels, but since they + * are applied mostly only to incoming channels that's not much of a problem. + */ +typedef struct MUST_USE_STRUCT LDKChannelHandshakeLimits { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelHandshakeLimits *inner; + bool is_owned; +} LDKChannelHandshakeLimits; + + + +/** + * Options which apply on a per-channel basis and may change at runtime or based on negotiation + * with our counterparty. + */ +typedef struct MUST_USE_STRUCT LDKChannelConfig { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelConfig *inner; + bool is_owned; +} LDKChannelConfig; + +typedef struct LDKu8slice { + const uint8_t *data; + uintptr_t datalen; +} LDKu8slice; + + + +/** + * Top-level config which holds ChannelHandshakeLimits and ChannelConfig. + * + * Default::default() provides sane defaults for most configurations + * (but currently with 0 relay fees!) + */ +typedef struct MUST_USE_STRUCT LDKUserConfig { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUserConfig *inner; + bool is_owned; +} LDKUserConfig; + +typedef union LDKCResultPtr_C2TupleTempl_CVec_u8Z__u64_____ChainError { + LDKC2TupleTempl_CVec_u8Z__u64 *result; + LDKChainError *err; +} LDKCResultPtr_C2TupleTempl_CVec_u8Z__u64_____ChainError; + +typedef struct LDKCResultTempl_C2TupleTempl_CVec_u8Z__u64_____ChainError { + LDKCResultPtr_C2TupleTempl_CVec_u8Z__u64_____ChainError contents; + bool result_ok; +} LDKCResultTempl_C2TupleTempl_CVec_u8Z__u64_____ChainError; + +typedef LDKCResultTempl_C2TupleTempl_CVec_u8Z__u64_____ChainError LDKCResult_C2Tuple_Scriptu64ZChainErrorZ; + +typedef struct LDKCVecTempl_usize { + uintptr_t *data; + uintptr_t datalen; +} LDKCVecTempl_usize; + +typedef LDKCVecTempl_usize LDKCVec_usizeZ; + +/** + * An interface to request notification of certain scripts as they appear the + * chain. + * + * Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're + * called from inside the library in response to ChainListener events, P2P events, or timer + * events). + */ +typedef struct LDKChainWatchInterface { + void *this_arg; + /** + * Provides a txid/random-scriptPubKey-in-the-tx which much be watched for. + */ + void (*install_watch_tx)(const void *this_arg, const uint8_t (*txid)[32], LDKu8slice script_pub_key); + /** + * Provides an outpoint which must be watched for, providing any transactions which spend the + * given outpoint. + */ + void (*install_watch_outpoint)(const void *this_arg, LDKC2Tuple_Txidu32Z outpoint, LDKu8slice out_script); + /** + * Indicates that a listener needs to see all transactions. + */ + void (*watch_all_txn)(const void *this_arg); + /** + * Gets the script and value in satoshis for a given unspent transaction output given a + * short_channel_id (aka unspent_tx_output_identier). For BTC/tBTC channels the top three + * bytes are the block height, the next 3 the transaction index within the block, and the + * final two the output within the transaction. + */ + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ (*get_chain_utxo)(const void *this_arg, LDKThirtyTwoBytes genesis_hash, uint64_t unspent_tx_output_identifier); + /** + * Gets the list of transaction indices within a given block that the ChainWatchInterface is + * watching for. + */ + LDKCVec_usizeZ (*filter_block)(const void *this_arg, LDKu8slice block); + /** + * Returns a usize that changes when the ChainWatchInterface's watched data is modified. + * Users of `filter_block` should pre-save a copy of `reentered`'s return value and use it to + * determine whether they need to re-filter a given block. + */ + uintptr_t (*reentered)(const void *this_arg); + void (*free)(void *this_arg); +} LDKChainWatchInterface; + +/** + * A reference to a serialized transaction, in (pointer, length) form. + * This type does *not* own its own memory, so access to it after, eg, the call in which it was + * provided to you are invalid. + */ +typedef struct LDKTransaction { + const uint8_t *data; + uintptr_t datalen; +} LDKTransaction; + +/** + * An interface to send a transaction to the Bitcoin network. + */ +typedef struct LDKBroadcasterInterface { + void *this_arg; + /** + * Sends a transaction out to (hopefully) be mined. + */ + void (*broadcast_transaction)(const void *this_arg, LDKTransaction tx); + void (*free)(void *this_arg); +} LDKBroadcasterInterface; + +typedef struct LDKCVecTempl_CVec_u8Z { + LDKCVec_u8Z *data; + uintptr_t datalen; +} LDKCVecTempl_CVec_u8Z; + +typedef LDKCVecTempl_CVec_u8Z LDKCVec_TransactionZ; + +typedef struct LDKusizeslice { + const uintptr_t *data; + uintptr_t datalen; +} LDKusizeslice; + +/** + * A trait indicating a desire to listen for events from the chain + */ +typedef struct LDKChainListener { + void *this_arg; + /** + * Notifies a listener that a block was connected. + * + * The txn_matched array should be set to references to transactions which matched the + * relevant installed watch outpoints/txn, or the full set of transactions in the block. + * + * Note that if txn_matched includes only matched transactions, and a new + * transaction/outpoint is watched during a block_connected call, the block *must* be + * re-scanned with the new transaction/outpoints and block_connected should be called + * again with the same header and (at least) the new transactions. + * + * Note that if non-new transaction/outpoints are be registered during a call, a second call + * *must not* happen. + * + * This also means those counting confirmations using block_connected callbacks should watch + * for duplicate headers and not count them towards confirmations! + */ + void (*block_connected)(const void *this_arg, const uint8_t (*header)[80], uint32_t height, LDKCVec_TransactionZ txn_matched, LDKusizeslice indexes_of_txn_matched); + /** + * Notifies a listener that a block was disconnected. + * Unlike block_connected, this *must* never be called twice for the same disconnect event. + * Height must be the one of the block which was disconnected (not new height of the best chain) + */ + void (*block_disconnected)(const void *this_arg, const uint8_t (*header)[80], uint32_t disconnected_height); + void (*free)(void *this_arg); +} LDKChainListener; + +/** + * A trait which should be implemented to provide feerate information on a number of time + * horizons. + * + * Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're + * called from inside the library in response to ChainListener events, P2P events, or timer + * events). + */ +typedef struct LDKFeeEstimator { + void *this_arg; + /** + * Gets estimated satoshis of fee required per 1000 Weight-Units. + * + * Must be no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later round-downs + * don't put us below 1 satoshi-per-byte). + * + * This translates to: + * * satoshis-per-byte * 250 + * * ceil(satoshis-per-kbyte / 4) + */ + uint32_t (*get_est_sat_per_1000_weight)(const void *this_arg, LDKConfirmationTarget confirmation_target); + void (*free)(void *this_arg); +} LDKFeeEstimator; + + + +/** + * Utility for tracking registered txn/outpoints and checking for matches + */ +typedef struct MUST_USE_STRUCT LDKChainWatchedUtil { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChainWatchedUtil *inner; + bool is_owned; +} LDKChainWatchedUtil; + + + +/** + * Utility for notifying listeners about new blocks, and handling block rescans if new watch + * data is registered. + * + * Rather than using a plain BlockNotifier, it is preferable to use either a BlockNotifierArc + * or a BlockNotifierRef for conciseness. See their documentation for more details, but essentially + * you should default to using a BlockNotifierRef, and use a BlockNotifierArc instead when you + * require ChainListeners with static lifetimes, such as when you're using lightning-net-tokio. + */ +typedef struct MUST_USE_STRUCT LDKBlockNotifier { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeBlockNotifier *inner; + bool is_owned; +} LDKBlockNotifier; + + + +/** + * Utility to capture some common parts of ChainWatchInterface implementors. + * + * Keeping a local copy of this in a ChainWatchInterface implementor is likely useful. + */ +typedef struct MUST_USE_STRUCT LDKChainWatchInterfaceUtil { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChainWatchInterfaceUtil *inner; + bool is_owned; +} LDKChainWatchInterfaceUtil; + + + +/** + * One counterparty's public keys which do not change over the life of a channel. + */ +typedef struct MUST_USE_STRUCT LDKChannelPublicKeys { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelPublicKeys *inner; + bool is_owned; +} LDKChannelPublicKeys; + + + +/** + * The per-commitment point and a set of pre-calculated public keys used for transaction creation + * in the signer. + * The pre-calculated keys are an optimization, because ChannelKeys has enough + * information to re-derive them. + */ +typedef struct MUST_USE_STRUCT LDKPreCalculatedTxCreationKeys { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePreCalculatedTxCreationKeys *inner; + bool is_owned; +} LDKPreCalculatedTxCreationKeys; + +typedef struct LDKCVecTempl_HTLCOutputInCommitment { + LDKHTLCOutputInCommitment *data; + uintptr_t datalen; +} LDKCVecTempl_HTLCOutputInCommitment; + +typedef LDKCVecTempl_HTLCOutputInCommitment LDKCVec_HTLCOutputInCommitmentZ; + + + +/** + * We use this to track local commitment transactions and put off signing them until we are ready + * to broadcast. This class can be used inside a signer implementation to generate a signature + * given the relevant secret key. + */ +typedef struct MUST_USE_STRUCT LDKLocalCommitmentTransaction { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeLocalCommitmentTransaction *inner; + bool is_owned; +} LDKLocalCommitmentTransaction; + + + +/** + * The unsigned part of a channel_announcement + */ +typedef struct MUST_USE_STRUCT LDKUnsignedChannelAnnouncement { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUnsignedChannelAnnouncement *inner; + bool is_owned; +} LDKUnsignedChannelAnnouncement; + +/** + * Set of lightning keys needed to operate a channel as described in BOLT 3. + * + * Signing services could be implemented on a hardware wallet. In this case, + * the current ChannelKeys would be a front-end on top of a communication + * channel connected to your secure device and lightning key material wouldn't + * reside on a hot server. Nevertheless, a this deployment would still need + * to trust the ChannelManager to avoid loss of funds as this latest component + * could ask to sign commitment transaction with HTLCs paying to attacker pubkeys. + * + * A more secure iteration would be to use hashlock (or payment points) to pair + * invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager + * at the price of more state and computation on the hardware wallet side. In the future, + * we are looking forward to design such interface. + * + * In any case, ChannelMonitor or fallback watchtowers are always going to be trusted + * to act, as liveness and breach reply correctness are always going to be hard requirements + * of LN security model, orthogonal of key management issues. + * + * If you're implementing a custom signer, you almost certainly want to implement + * Readable/Writable to serialize out a unique reference to this set of keys so + * that you can serialize the full ChannelManager object. + * + */ +typedef struct LDKChannelKeys { + void *this_arg; + /** + * Gets the per-commitment point for a specific commitment number + * + * Note that the commitment number starts at (1 << 48) - 1 and counts backwards. + */ + LDKPublicKey (*get_per_commitment_point)(const void *this_arg, uint64_t idx); + /** + * Gets the commitment secret for a specific commitment number as part of the revocation process + * + * An external signer implementation should error here if the commitment was already signed + * and should refuse to sign it in the future. + * + * May be called more than once for the same index. + * + * Note that the commitment number starts at (1 << 48) - 1 and counts backwards. + * TODO: return a Result so we can signal a validation error + */ + LDKThirtyTwoBytes (*release_commitment_secret)(const void *this_arg, uint64_t idx); + /** + * Gets the local channel public keys and basepoints + */ + LDKChannelPublicKeys pubkeys; + /** + * Fill in the pubkeys field as a reference to it will be given to Rust after this returns + * Note that this takes a pointer to this object, not the this_ptr like other methods do + * This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating. + */ + void (*set_pubkeys)(const LDKChannelKeys*); + /** + * Gets arbitrary identifiers describing the set of keys which are provided back to you in + * some SpendableOutputDescriptor types. These should be sufficient to identify this + * ChannelKeys object uniquely and lookup or re-derive its keys. + */ + LDKC2Tuple_u64u64Z (*key_derivation_params)(const void *this_arg); + /** + * Create a signature for a remote commitment transaction and associated HTLC transactions. + * + * Note that if signing fails or is rejected, the channel will be force-closed. + */ + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*sign_remote_commitment)(const void *this_arg, uint32_t feerate_per_kw, LDKTransaction commitment_tx, const LDKPreCalculatedTxCreationKeys *keys, LDKCVec_HTLCOutputInCommitmentZ htlcs); + /** + * Create a signature for a local commitment transaction. This will only ever be called with + * the same local_commitment_tx (or a copy thereof), though there are currently no guarantees + * that it will not be called multiple times. + * An external signer implementation should check that the commitment has not been revoked. + */ + LDKCResult_SignatureNoneZ (*sign_local_commitment)(const void *this_arg, const LDKLocalCommitmentTransaction *local_commitment_tx); + /** + * Create a signature for each HTLC transaction spending a local commitment transaction. + * + * Unlike sign_local_commitment, this may be called multiple times with *different* + * local_commitment_tx values. While this will never be called with a revoked + * local_commitment_tx, it is possible that it is called with the second-latest + * local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary + * ChannelMonitor decided to broadcast before it had been updated to the latest. + * + * Either an Err should be returned, or a Vec with one entry for each HTLC which exists in + * local_commitment_tx. For those HTLCs which have transaction_output_index set to None + * (implying they were considered dust at the time the commitment transaction was negotiated), + * a corresponding None should be included in the return value. All other positions in the + * return value must contain a signature. + */ + LDKCResult_CVec_SignatureZNoneZ (*sign_local_commitment_htlc_transactions)(const void *this_arg, const LDKLocalCommitmentTransaction *local_commitment_tx); + /** + * Create a signature for the given input in a transaction spending an HTLC or commitment + * transaction output when our counterparty broadcasts an old state. + * + * A justice transaction may claim multiples outputs at the same time if timelocks are + * similar, but only a signature for the input at index `input` should be signed for here. + * It may be called multiples time for same output(s) if a fee-bump is needed with regards + * to an upcoming timelock expiration. + * + * Amount is value of the output spent by this input, committed to in the BIP 143 signature. + * + * per_commitment_key is revocation secret which was provided by our counterparty when they + * revoked the state which they eventually broadcast. It's not a _local_ secret key and does + * not allow the spending of any funds by itself (you need our local revocation_secret to do + * so). + * + * htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus + * changing the format of the witness script (which is committed to in the BIP 143 + * signatures). + */ + LDKCResult_SignatureNoneZ (*sign_justice_transaction)(const void *this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const LDKHTLCOutputInCommitment *htlc); + /** + * Create a signature for a claiming transaction for a HTLC output on a remote commitment + * transaction, either offered or received. + * + * Such a transaction may claim multiples offered outputs at same time if we know the + * preimage for each when we create it, but only the input at index `input` should be + * signed for here. It may be called multiple times for same output(s) if a fee-bump is + * needed with regards to an upcoming timelock expiration. + * + * Witness_script is either a offered or received script as defined in BOLT3 for HTLC + * outputs. + * + * Amount is value of the output spent by this input, committed to in the BIP 143 signature. + * + * Per_commitment_point is the dynamic point corresponding to the channel state + * detected onchain. It has been generated by our counterparty and is used to derive + * channel state keys, which are then included in the witness script and committed to in the + * BIP 143 signature. + */ + LDKCResult_SignatureNoneZ (*sign_remote_htlc_transaction)(const void *this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment *htlc); + /** + * Create a signature for a (proposed) closing transaction. + * + * Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have + * chosen to forgo their output as dust. + */ + LDKCResult_SignatureNoneZ (*sign_closing_transaction)(const void *this_arg, LDKTransaction closing_tx); + /** + * Signs a channel announcement message with our funding key, proving it comes from one + * of the channel participants. + * + * Note that if this fails or is rejected, the channel will not be publicly announced and + * our counterparty may (though likely will not) close the channel on us for violating the + * protocol. + */ + LDKCResult_SignatureNoneZ (*sign_channel_announcement)(const void *this_arg, const LDKUnsignedChannelAnnouncement *msg); + /** + * Set the remote channel basepoints and remote/local to_self_delay. + * This is done immediately on incoming channels and as soon as the channel is accepted on outgoing channels. + * + * We bind local_to_self_delay late here for API convenience. + * + * Will be called before any signatures are applied. + */ + void (*on_accept)(void *this_arg, const LDKChannelPublicKeys *channel_points, uint16_t remote_to_self_delay, uint16_t local_to_self_delay); + void *(*clone)(const void *this_arg); + void (*free)(void *this_arg); +} LDKChannelKeys; + +typedef struct LDKSecretKey { + uint8_t bytes[32]; +} LDKSecretKey; + +/** + * A trait to describe an object which can get user secrets and key material. + */ +typedef struct LDKKeysInterface { + void *this_arg; + /** + * Get node secret key (aka node_id or network_key) + */ + LDKSecretKey (*get_node_secret)(const void *this_arg); + /** + * Get destination redeemScript to encumber static protocol exit points. + */ + LDKCVec_u8Z (*get_destination_script)(const void *this_arg); + /** + * Get shutdown_pubkey to use as PublicKey at channel closure + */ + LDKPublicKey (*get_shutdown_pubkey)(const void *this_arg); + /** + * Get a new set of ChannelKeys for per-channel secrets. These MUST be unique even if you + * restarted with some stale data! + */ + LDKChannelKeys (*get_channel_keys)(const void *this_arg, bool inbound, uint64_t channel_value_satoshis); + /** + * Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting + * onion packets and for temporary channel IDs. There is no requirement that these be + * persisted anywhere, though they must be unique across restarts. + */ + LDKThirtyTwoBytes (*get_secure_random_bytes)(const void *this_arg); + void (*free)(void *this_arg); +} LDKKeysInterface; + + + +/** + * A simple implementation of ChannelKeys that just keeps the private keys in memory. + */ +typedef struct MUST_USE_STRUCT LDKInMemoryChannelKeys { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeInMemoryChannelKeys *inner; + bool is_owned; +} LDKInMemoryChannelKeys; + + + +/** + * Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key + * and derives keys from that. + * + * Your node_id is seed/0' + * ChannelMonitor closes may use seed/1' + * Cooperative closes may use seed/2' + * The two close keys may be needed to claim on-chain funds! + */ +typedef struct MUST_USE_STRUCT LDKKeysManager { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeKeysManager *inner; + bool is_owned; +} LDKKeysManager; + + + +/** + * A ChannelMonitor handles chain events (blocks connected and disconnected) and generates + * on-chain transactions to ensure no loss of funds occurs. + * + * You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date + * information and are actively monitoring the chain. + * + * Pending Events or updated HTLCs which have not yet been read out by + * get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and + * reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events + * gotten are fully handled before re-serializing the new state. + */ +typedef struct MUST_USE_STRUCT LDKChannelMonitor { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelMonitor *inner; + bool is_owned; +} LDKChannelMonitor; + + + +/** + * An update generated by the underlying Channel itself which contains some new information the + * ChannelMonitor should be made aware of. + */ +typedef struct MUST_USE_STRUCT LDKChannelMonitorUpdate { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelMonitorUpdate *inner; + bool is_owned; +} LDKChannelMonitorUpdate; + + + +/** + * An event to be processed by the ChannelManager. + */ +typedef struct MUST_USE_STRUCT LDKMonitorEvent { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeMonitorEvent *inner; + bool is_owned; +} LDKMonitorEvent; + +typedef struct LDKCVecTempl_MonitorEvent { + LDKMonitorEvent *data; + uintptr_t datalen; +} LDKCVecTempl_MonitorEvent; + +typedef LDKCVecTempl_MonitorEvent LDKCVec_MonitorEventZ; + +/** + * Simple trait indicating ability to track a set of ChannelMonitors and multiplex events between + * them. Generally should be implemented by keeping a local SimpleManyChannelMonitor and passing + * events to it, while also taking any add/update_monitor events and passing them to some remote + * server(s). + * + * In general, you must always have at least one local copy in memory, which must never fail to + * update (as it is responsible for broadcasting the latest state in case the channel is closed), + * and then persist it to various on-disk locations. If, for some reason, the in-memory copy fails + * to update (eg out-of-memory or some other condition), you must immediately shut down without + * taking any further action such as writing the current state to disk. This should likely be + * accomplished via panic!() or abort(). + * + * Note that any updates to a channel's monitor *must* be applied to each instance of the + * channel's monitor everywhere (including remote watchtowers) *before* this function returns. If + * an update occurs and a remote watchtower is left with old state, it may broadcast transactions + * which we have revoked, allowing our counterparty to claim all funds in the channel! + * + * User needs to notify implementors of ManyChannelMonitor when a new block is connected or + * disconnected using their `block_connected` and `block_disconnected` methods. However, rather + * than calling these methods directly, the user should register implementors as listeners to the + * BlockNotifier and call the BlockNotifier's `block_(dis)connected` methods, which will notify + * all registered listeners in one go. + */ +typedef struct LDKManyChannelMonitor { + void *this_arg; + /** + * Adds a monitor for the given `funding_txo`. + * + * Implementer must also ensure that the funding_txo txid *and* outpoint are registered with + * any relevant ChainWatchInterfaces such that the provided monitor receives block_connected + * callbacks with the funding transaction, or any spends of it. + * + * Further, the implementer must also ensure that each output returned in + * monitor.get_outputs_to_watch() is registered to ensure that the provided monitor learns about + * any spends of any of the outputs. + * + * Any spends of outputs which should have been registered which aren't passed to + * ChannelMonitors via block_connected may result in FUNDS LOSS. + */ + LDKCResult_NoneChannelMonitorUpdateErrZ (*add_monitor)(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor); + /** + * Updates a monitor for the given `funding_txo`. + * + * Implementer must also ensure that the funding_txo txid *and* outpoint are registered with + * any relevant ChainWatchInterfaces such that the provided monitor receives block_connected + * callbacks with the funding transaction, or any spends of it. + * + * Further, the implementer must also ensure that each output returned in + * monitor.get_watch_outputs() is registered to ensure that the provided monitor learns about + * any spends of any of the outputs. + * + * Any spends of outputs which should have been registered which aren't passed to + * ChannelMonitors via block_connected may result in FUNDS LOSS. + */ + LDKCResult_NoneChannelMonitorUpdateErrZ (*update_monitor)(const void *this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate monitor); + /** + * Used by ChannelManager to get list of HTLC resolved onchain and which needed to be updated + * with success or failure. + * + * You should probably just call through to + * ChannelMonitor::get_and_clear_pending_monitor_events() for each ChannelMonitor and return + * the full list. + */ + LDKCVec_MonitorEventZ (*get_and_clear_pending_monitor_events)(const void *this_arg); + void (*free)(void *this_arg); +} LDKManyChannelMonitor; + + + +/** + * Manager which keeps track of a number of channels and sends messages to the appropriate + * channel, also tracking HTLC preimages and forwarding onion packets appropriately. + * + * Implements ChannelMessageHandler, handling the multi-channel parts and passing things through + * to individual Channels. + * + * Implements Writeable to write out all channel state to disk. Implies peer_disconnected() for + * all peers during write/read (though does not modify this instance, only the instance being + * serialized). This will result in any channels which have not yet exchanged funding_created (ie + * called funding_transaction_generated for outbound channels). + * + * Note that you can be a bit lazier about writing out ChannelManager than you can be with + * ChannelMonitors. With ChannelMonitors you MUST write each monitor update out to disk before + * returning from ManyChannelMonitor::add_/update_monitor, with ChannelManagers, writing updates + * happens out-of-band (and will prevent any other ChannelManager operations from occurring during + * the serialization process). If the deserialized version is out-of-date compared to the + * ChannelMonitors passed by reference to read(), those channels will be force-closed based on the + * ChannelMonitor state and no funds will be lost (mod on-chain transaction fees). + * + * Note that the deserializer is only implemented for (Sha256dHash, ChannelManager), which + * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along + * the \"reorg path\" (ie call block_disconnected() until you get to a common block and then call + * block_connected() to step towards your best block) upon deserialization before using the + * object! + * + * Note that ChannelManager is responsible for tracking liveness of its channels and generating + * ChannelUpdate messages informing peers that the channel is temporarily disabled. To avoid + * spam due to quick disconnection/reconnection, updates are not sent until the channel has been + * offline for a full minute. In order to track this, you must call + * timer_chan_freshness_every_min roughly once per minute, though it doesn't have to be perfect. + * + * Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager + * a SimpleRefChannelManager, for conciseness. See their documentation for more details, but + * essentially you should default to using a SimpleRefChannelManager, and use a + * SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when + * you're using lightning-net-tokio. + */ +typedef struct MUST_USE_STRUCT LDKChannelManager { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelManager *inner; + bool is_owned; +} LDKChannelManager; + + + +/** + * Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels + */ +typedef struct MUST_USE_STRUCT LDKChannelDetails { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelDetails *inner; + bool is_owned; +} LDKChannelDetails; + + + +/** + * Features used within an `init` message. + */ +typedef struct MUST_USE_STRUCT LDKInitFeatures { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeInitFeatures *inner; + bool is_owned; +} LDKInitFeatures; + +typedef struct LDKCVecTempl_ChannelDetails { + LDKChannelDetails *data; + uintptr_t datalen; +} LDKCVecTempl_ChannelDetails; + +typedef LDKCVecTempl_ChannelDetails LDKCVec_ChannelDetailsZ; + + + +/** + * A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP, + * it can take multiple paths. Each path is composed of one or more hops through the network. + */ +typedef struct MUST_USE_STRUCT LDKRoute { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeRoute *inner; + bool is_owned; +} LDKRoute; + +typedef struct LDKThreeBytes { + uint8_t data[3]; +} LDKThreeBytes; + +typedef struct LDKFourBytes { + uint8_t data[4]; +} LDKFourBytes; + +typedef struct LDKSixteenBytes { + uint8_t data[16]; +} LDKSixteenBytes; + +typedef struct LDKTenBytes { + uint8_t data[10]; +} LDKTenBytes; + +/** + * An address which can be used to connect to a remote peer + */ +typedef enum LDKNetAddress_Tag { + /** + * An IPv4 address/port on which the peer is listening. + */ + LDKNetAddress_IPv4, + /** + * An IPv6 address/port on which the peer is listening. + */ + LDKNetAddress_IPv6, + /** + * An old-style Tor onion address/port on which the peer is listening. + */ + LDKNetAddress_OnionV2, + /** + * A new-style Tor onion address/port on which the peer is listening. + * To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version, + * wrap as base32 and append \".onion\". + */ + LDKNetAddress_OnionV3, + /** + * Must be last for serialization purposes + */ + LDKNetAddress_Sentinel, +} LDKNetAddress_Tag; + +typedef struct LDKNetAddress_LDKIPv4_Body { + LDKFourBytes addr; + uint16_t port; +} LDKNetAddress_LDKIPv4_Body; + +typedef struct LDKNetAddress_LDKIPv6_Body { + LDKSixteenBytes addr; + uint16_t port; +} LDKNetAddress_LDKIPv6_Body; + +typedef struct LDKNetAddress_LDKOnionV2_Body { + LDKTenBytes addr; + uint16_t port; +} LDKNetAddress_LDKOnionV2_Body; + +typedef struct LDKNetAddress_LDKOnionV3_Body { + LDKThirtyTwoBytes ed25519_pubkey; + uint16_t checksum; + uint8_t version; + uint16_t port; +} LDKNetAddress_LDKOnionV3_Body; + +typedef struct LDKNetAddress { + LDKNetAddress_Tag tag; + union { + LDKNetAddress_LDKIPv4_Body i_pv4; + LDKNetAddress_LDKIPv6_Body i_pv6; + LDKNetAddress_LDKOnionV2_Body onion_v2; + LDKNetAddress_LDKOnionV3_Body onion_v3; + }; +} LDKNetAddress; + +typedef struct LDKCVecTempl_NetAddress { + LDKNetAddress *data; + uintptr_t datalen; +} LDKCVecTempl_NetAddress; + +typedef LDKCVecTempl_NetAddress LDKCVec_NetAddressZ; + + + +/** + * An update_add_htlc message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKUpdateAddHTLC { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUpdateAddHTLC *inner; + bool is_owned; +} LDKUpdateAddHTLC; + + + +/** + * An update_fulfill_htlc message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKUpdateFulfillHTLC { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUpdateFulfillHTLC *inner; + bool is_owned; +} LDKUpdateFulfillHTLC; + + + +/** + * An update_fail_htlc message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKUpdateFailHTLC { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUpdateFailHTLC *inner; + bool is_owned; +} LDKUpdateFailHTLC; + + + +/** + * An update_fail_malformed_htlc message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKUpdateFailMalformedHTLC { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUpdateFailMalformedHTLC *inner; + bool is_owned; +} LDKUpdateFailMalformedHTLC; + + + +/** + * A commitment_signed message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKCommitmentSigned { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeCommitmentSigned *inner; + bool is_owned; +} LDKCommitmentSigned; + + + +/** + * An update_fee message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKUpdateFee { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUpdateFee *inner; + bool is_owned; +} LDKUpdateFee; + + + +/** + * An init message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKInit { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeInit *inner; + bool is_owned; +} LDKInit; + +/** + * A trait to describe an object which can receive channel messages. + * + * Messages MAY be called in parallel when they originate from different their_node_ids, however + * they MUST NOT be called in parallel when the two calls have the same their_node_id. + */ +typedef struct LDKChannelMessageHandler { + void *this_arg; + /** + * Handle an incoming open_channel message from the given peer. + */ + void (*handle_open_channel)(const void *this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel *msg); + /** + * Handle an incoming accept_channel message from the given peer. + */ + void (*handle_accept_channel)(const void *this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel *msg); + /** + * Handle an incoming funding_created message from the given peer. + */ + void (*handle_funding_created)(const void *this_arg, LDKPublicKey their_node_id, const LDKFundingCreated *msg); + /** + * Handle an incoming funding_signed message from the given peer. + */ + void (*handle_funding_signed)(const void *this_arg, LDKPublicKey their_node_id, const LDKFundingSigned *msg); + /** + * Handle an incoming funding_locked message from the given peer. + */ + void (*handle_funding_locked)(const void *this_arg, LDKPublicKey their_node_id, const LDKFundingLocked *msg); + /** + * Handle an incoming shutdown message from the given peer. + */ + void (*handle_shutdown)(const void *this_arg, LDKPublicKey their_node_id, const LDKShutdown *msg); + /** + * Handle an incoming closing_signed message from the given peer. + */ + void (*handle_closing_signed)(const void *this_arg, LDKPublicKey their_node_id, const LDKClosingSigned *msg); + /** + * Handle an incoming update_add_htlc message from the given peer. + */ + void (*handle_update_add_htlc)(const void *this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC *msg); + /** + * Handle an incoming update_fulfill_htlc message from the given peer. + */ + void (*handle_update_fulfill_htlc)(const void *this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC *msg); + /** + * Handle an incoming update_fail_htlc message from the given peer. + */ + void (*handle_update_fail_htlc)(const void *this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC *msg); + /** + * Handle an incoming update_fail_malformed_htlc message from the given peer. + */ + void (*handle_update_fail_malformed_htlc)(const void *this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC *msg); + /** + * Handle an incoming commitment_signed message from the given peer. + */ + void (*handle_commitment_signed)(const void *this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned *msg); + /** + * Handle an incoming revoke_and_ack message from the given peer. + */ + void (*handle_revoke_and_ack)(const void *this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK *msg); + /** + * Handle an incoming update_fee message from the given peer. + */ + void (*handle_update_fee)(const void *this_arg, LDKPublicKey their_node_id, const LDKUpdateFee *msg); + /** + * Handle an incoming announcement_signatures message from the given peer. + */ + void (*handle_announcement_signatures)(const void *this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures *msg); + /** + * Indicates a connection to the peer failed/an existing connection was lost. If no connection + * is believed to be possible in the future (eg they're sending us messages we don't + * understand or indicate they require unknown feature bits), no_connection_possible is set + * and any outstanding channels should be failed. + */ + void (*peer_disconnected)(const void *this_arg, LDKPublicKey their_node_id, bool no_connection_possible); + /** + * Handle a peer reconnecting, possibly generating channel_reestablish message(s). + */ + void (*peer_connected)(const void *this_arg, LDKPublicKey their_node_id, const LDKInit *msg); + /** + * Handle an incoming channel_reestablish message from the given peer. + */ + void (*handle_channel_reestablish)(const void *this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish *msg); + /** + * Handle an incoming error message from the given peer. + */ + void (*handle_error)(const void *this_arg, LDKPublicKey their_node_id, const LDKErrorMessage *msg); + LDKMessageSendEventsProvider MessageSendEventsProvider; + void (*free)(void *this_arg); +} LDKChannelMessageHandler; + + + +/** + * Arguments for the creation of a ChannelManager that are not deserialized. + * + * At a high-level, the process for deserializing a ChannelManager and resuming normal operation + * is: + * 1) Deserialize all stored ChannelMonitors. + * 2) Deserialize the ChannelManager by filling in this struct and calling <(Sha256dHash, + * ChannelManager)>::read(reader, args). + * This may result in closing some Channels if the ChannelMonitor is newer than the stored + * ChannelManager state to ensure no loss of funds. Thus, transactions may be broadcasted. + * 3) Register all relevant ChannelMonitor outpoints with your chain watch mechanism using + * ChannelMonitor::get_monitored_outpoints and ChannelMonitor::get_funding_txo(). + * 4) Reconnect blocks on your ChannelMonitors. + * 5) Move the ChannelMonitors into your local ManyChannelMonitor. + * 6) Disconnect/connect blocks on the ChannelManager. + * 7) Register the new ChannelManager with your ChainWatchInterface. + */ +typedef struct MUST_USE_STRUCT LDKChannelManagerReadArgs { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelManagerReadArgs *inner; + bool is_owned; +} LDKChannelManagerReadArgs; + +typedef struct LDKCVecTempl_ChannelMonitor { + LDKChannelMonitor *data; + uintptr_t datalen; +} LDKCVecTempl_ChannelMonitor; + +typedef LDKCVecTempl_ChannelMonitor LDKCVec_ChannelMonitorZ; + + + +/** + * Simple structure send back by ManyChannelMonitor in case of HTLC detected onchain from a + * forward channel and from which info are needed to update HTLC in a backward channel. + */ +typedef struct MUST_USE_STRUCT LDKHTLCUpdate { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeHTLCUpdate *inner; + bool is_owned; +} LDKHTLCUpdate; + + + +/** + * An error in decoding a message or struct. + */ +typedef struct MUST_USE_STRUCT LDKDecodeError { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeDecodeError *inner; + bool is_owned; +} LDKDecodeError; + + + +/** + * A ping message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKPing { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePing *inner; + bool is_owned; +} LDKPing; + + + +/** + * A pong message to be sent or received from a peer + */ +typedef struct MUST_USE_STRUCT LDKPong { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePong *inner; + bool is_owned; +} LDKPong; + + + +/** + * Proof that the sender knows the per-commitment secret of the previous commitment transaction. + * This is used to convince the recipient that the channel is at a certain commitment + * number even if they lost that data due to a local failure. Of course, the peer may lie + * and even later commitments may have been revoked. + */ +typedef struct MUST_USE_STRUCT LDKDataLossProtect { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeDataLossProtect *inner; + bool is_owned; +} LDKDataLossProtect; + + + +/** + * The unsigned part of a node_announcement + */ +typedef struct MUST_USE_STRUCT LDKUnsignedNodeAnnouncement { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUnsignedNodeAnnouncement *inner; + bool is_owned; +} LDKUnsignedNodeAnnouncement; + + + +/** + * The unsigned part of a channel_update + */ +typedef struct MUST_USE_STRUCT LDKUnsignedChannelUpdate { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeUnsignedChannelUpdate *inner; + bool is_owned; +} LDKUnsignedChannelUpdate; + + + +/** + * An Err type for failure to process messages. + */ +typedef struct MUST_USE_STRUCT LDKLightningError { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeLightningError *inner; + bool is_owned; +} LDKLightningError; + +typedef struct LDKCVecTempl_UpdateAddHTLC { + LDKUpdateAddHTLC *data; + uintptr_t datalen; +} LDKCVecTempl_UpdateAddHTLC; + +typedef LDKCVecTempl_UpdateAddHTLC LDKCVec_UpdateAddHTLCZ; + +typedef struct LDKCVecTempl_UpdateFulfillHTLC { + LDKUpdateFulfillHTLC *data; + uintptr_t datalen; +} LDKCVecTempl_UpdateFulfillHTLC; + +typedef LDKCVecTempl_UpdateFulfillHTLC LDKCVec_UpdateFulfillHTLCZ; + +typedef struct LDKCVecTempl_UpdateFailHTLC { + LDKUpdateFailHTLC *data; + uintptr_t datalen; +} LDKCVecTempl_UpdateFailHTLC; + +typedef LDKCVecTempl_UpdateFailHTLC LDKCVec_UpdateFailHTLCZ; + +typedef struct LDKCVecTempl_UpdateFailMalformedHTLC { + LDKUpdateFailMalformedHTLC *data; + uintptr_t datalen; +} LDKCVecTempl_UpdateFailMalformedHTLC; + +typedef LDKCVecTempl_UpdateFailMalformedHTLC LDKCVec_UpdateFailMalformedHTLCZ; + +typedef union LDKCResultPtr_bool__LightningError { + bool *result; + LDKLightningError *err; +} LDKCResultPtr_bool__LightningError; + +typedef struct LDKCResultTempl_bool__LightningError { + LDKCResultPtr_bool__LightningError contents; + bool result_ok; +} LDKCResultTempl_bool__LightningError; + +typedef LDKCResultTempl_bool__LightningError LDKCResult_boolLightningErrorZ; + +typedef struct LDKCVecTempl_C3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate { + LDKC3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate *data; + uintptr_t datalen; +} LDKCVecTempl_C3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate; + +typedef LDKCVecTempl_C3TupleTempl_ChannelAnnouncement__ChannelUpdate__ChannelUpdate LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ; + +typedef struct LDKCVecTempl_NodeAnnouncement { + LDKNodeAnnouncement *data; + uintptr_t datalen; +} LDKCVecTempl_NodeAnnouncement; + +typedef LDKCVecTempl_NodeAnnouncement LDKCVec_NodeAnnouncementZ; + +/** + * A trait to describe an object which can receive routing messages. + */ +typedef struct LDKRoutingMessageHandler { + void *this_arg; + /** + * Handle an incoming node_announcement message, returning true if it should be forwarded on, + * false or returning an Err otherwise. + */ + LDKCResult_boolLightningErrorZ (*handle_node_announcement)(const void *this_arg, const LDKNodeAnnouncement *msg); + /** + * Handle a channel_announcement message, returning true if it should be forwarded on, false + * or returning an Err otherwise. + */ + LDKCResult_boolLightningErrorZ (*handle_channel_announcement)(const void *this_arg, const LDKChannelAnnouncement *msg); + /** + * Handle an incoming channel_update message, returning true if it should be forwarded on, + * false or returning an Err otherwise. + */ + LDKCResult_boolLightningErrorZ (*handle_channel_update)(const void *this_arg, const LDKChannelUpdate *msg); + /** + * Handle some updates to the route graph that we learned due to an outbound failed payment. + */ + void (*handle_htlc_fail_channel_update)(const void *this_arg, const LDKHTLCFailChannelUpdate *update); + /** + * Gets a subset of the channel announcements and updates required to dump our routing table + * to a remote node, starting at the short_channel_id indicated by starting_point and + * including the batch_amount entries immediately higher in numerical value than starting_point. + */ + LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ (*get_next_channel_announcements)(const void *this_arg, uint64_t starting_point, uint8_t batch_amount); + /** + * Gets a subset of the node announcements required to dump our routing table to a remote node, + * starting at the node *after* the provided publickey and including batch_amount entries + * immediately higher (as defined by ::cmp) than starting_point. + * If None is provided for starting_point, we start at the first node. + */ + LDKCVec_NodeAnnouncementZ (*get_next_node_announcements)(const void *this_arg, LDKPublicKey starting_point, uint8_t batch_amount); + /** + * Returns whether a full sync should be requested from a peer. + */ + bool (*should_request_full_sync)(const void *this_arg, LDKPublicKey node_id); + void (*free)(void *this_arg); +} LDKRoutingMessageHandler; + + + +/** + * Provides references to trait impls which handle different types of messages. + */ +typedef struct MUST_USE_STRUCT LDKMessageHandler { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeMessageHandler *inner; + bool is_owned; +} LDKMessageHandler; + +/** + * Provides an object which can be used to send data to and which uniquely identifies a connection + * to a remote host. You will need to be able to generate multiple of these which meet Eq and + * implement Hash to meet the PeerManager API. + * + * For efficiency, Clone should be relatively cheap for this type. + * + * You probably want to just extend an int and put a file descriptor in a struct and implement + * send_data. Note that if you are using a higher-level net library that may call close() itself, + * be careful to ensure you don't have races whereby you might register a new connection with an + * fd which is the same as a previous one which has yet to be removed via + * PeerManager::socket_disconnected(). + */ +typedef struct LDKSocketDescriptor { + void *this_arg; + /** + * Attempts to send some data from the given slice to the peer. + * + * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected. + * Note that in the disconnected case, socket_disconnected must still fire and further write + * attempts may occur until that time. + * + * If the returned size is smaller than data.len(), a write_available event must + * trigger the next time more data can be written. Additionally, until the a send_data event + * completes fully, no further read_events should trigger on the same peer! + * + * If a read_event on this descriptor had previously returned true (indicating that read + * events should be paused to prevent DoS in the send buffer), resume_read may be set + * indicating that read events on this descriptor should resume. A resume_read of false does + * *not* imply that further read events should be paused. + */ + uintptr_t (*send_data)(void *this_arg, LDKu8slice data, bool resume_read); + /** + * Disconnect the socket pointed to by this SocketDescriptor. Once this function returns, no + * more calls to write_buffer_space_avail, read_event or socket_disconnected may be made with + * this descriptor. No socket_disconnected call should be generated as a result of this call, + * though races may occur whereby disconnect_socket is called after a call to + * socket_disconnected but prior to socket_disconnected returning. + */ + void (*disconnect_socket)(void *this_arg); + bool (*eq)(const void *this_arg, const void *other_arg); + uint64_t (*hash)(const void *this_arg); + void *(*clone)(const void *this_arg); + void (*free)(void *this_arg); +} LDKSocketDescriptor; + + + +/** + * A PeerManager manages a set of peers, described by their SocketDescriptor and marshalls socket + * events into messages which it passes on to its MessageHandlers. + * + * Rather than using a plain PeerManager, it is preferable to use either a SimpleArcPeerManager + * a SimpleRefPeerManager, for conciseness. See their documentation for more details, but + * essentially you should default to using a SimpleRefPeerManager, and use a + * SimpleArcPeerManager when you require a PeerManager with a static lifetime, such as when + * you're using lightning-net-tokio. + */ +typedef struct MUST_USE_STRUCT LDKPeerManager { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativePeerManager *inner; + bool is_owned; +} LDKPeerManager; + +typedef struct LDKCVecTempl_PublicKey { + LDKPublicKey *data; + uintptr_t datalen; +} LDKCVecTempl_PublicKey; + +typedef LDKCVecTempl_PublicKey LDKCVec_PublicKeyZ; + +typedef union LDKCResultPtr_CVecTempl_u8_____PeerHandleError { + LDKCVecTempl_u8 *result; + LDKPeerHandleError *err; +} LDKCResultPtr_CVecTempl_u8_____PeerHandleError; + +typedef struct LDKCResultTempl_CVecTempl_u8_____PeerHandleError { + LDKCResultPtr_CVecTempl_u8_____PeerHandleError contents; + bool result_ok; +} LDKCResultTempl_CVecTempl_u8_____PeerHandleError; + +typedef LDKCResultTempl_CVecTempl_u8_____PeerHandleError LDKCResult_CVec_u8ZPeerHandleErrorZ; + +typedef union LDKCResultPtr_bool__PeerHandleError { + bool *result; + LDKPeerHandleError *err; +} LDKCResultPtr_bool__PeerHandleError; + +typedef struct LDKCResultTempl_bool__PeerHandleError { + LDKCResultPtr_bool__PeerHandleError contents; + bool result_ok; +} LDKCResultTempl_bool__PeerHandleError; + +typedef LDKCResultTempl_bool__PeerHandleError LDKCResult_boolPeerHandleErrorZ; + +typedef union LDKCResultPtr_SecretKey__Secp256k1Error { + LDKSecretKey *result; + LDKSecp256k1Error *err; +} LDKCResultPtr_SecretKey__Secp256k1Error; + +typedef struct LDKCResultTempl_SecretKey__Secp256k1Error { + LDKCResultPtr_SecretKey__Secp256k1Error contents; + bool result_ok; +} LDKCResultTempl_SecretKey__Secp256k1Error; + +typedef LDKCResultTempl_SecretKey__Secp256k1Error LDKCResult_SecretKeySecpErrorZ; + +typedef union LDKCResultPtr_PublicKey__Secp256k1Error { + LDKPublicKey *result; + LDKSecp256k1Error *err; +} LDKCResultPtr_PublicKey__Secp256k1Error; + +typedef struct LDKCResultTempl_PublicKey__Secp256k1Error { + LDKCResultPtr_PublicKey__Secp256k1Error contents; + bool result_ok; +} LDKCResultTempl_PublicKey__Secp256k1Error; + +typedef LDKCResultTempl_PublicKey__Secp256k1Error LDKCResult_PublicKeySecpErrorZ; + + + +/** + * The set of public keys which are used in the creation of one commitment transaction. + * These are derived from the channel base keys and per-commitment data. + * + * These keys are assumed to be good, either because the code derived them from + * channel basepoints via the new function, or they were obtained via + * PreCalculatedTxCreationKeys.trust_key_derivation because we trusted the source of the + * pre-calculated keys. + */ +typedef struct MUST_USE_STRUCT LDKTxCreationKeys { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeTxCreationKeys *inner; + bool is_owned; +} LDKTxCreationKeys; + +typedef union LDKCResultPtr_TxCreationKeys__Secp256k1Error { + LDKTxCreationKeys *result; + LDKSecp256k1Error *err; +} LDKCResultPtr_TxCreationKeys__Secp256k1Error; + +typedef struct LDKCResultTempl_TxCreationKeys__Secp256k1Error { + LDKCResultPtr_TxCreationKeys__Secp256k1Error contents; + bool result_ok; +} LDKCResultTempl_TxCreationKeys__Secp256k1Error; + +typedef LDKCResultTempl_TxCreationKeys__Secp256k1Error LDKCResult_TxCreationKeysSecpErrorZ; + +typedef struct LDKCVecTempl_C2TupleTempl_HTLCOutputInCommitment__Signature { + LDKC2TupleTempl_HTLCOutputInCommitment__Signature *data; + uintptr_t datalen; +} LDKCVecTempl_C2TupleTempl_HTLCOutputInCommitment__Signature; + +typedef LDKCVecTempl_C2TupleTempl_HTLCOutputInCommitment__Signature LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ; + + + +/** + * Features used within a `node_announcement` message. + */ +typedef struct MUST_USE_STRUCT LDKNodeFeatures { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNodeFeatures *inner; + bool is_owned; +} LDKNodeFeatures; + + + +/** + * Features used within a `channel_announcement` message. + */ +typedef struct MUST_USE_STRUCT LDKChannelFeatures { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelFeatures *inner; + bool is_owned; +} LDKChannelFeatures; + + + +/** + * A hop in a route + */ +typedef struct MUST_USE_STRUCT LDKRouteHop { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeRouteHop *inner; + bool is_owned; +} LDKRouteHop; + +typedef struct LDKCVecTempl_RouteHop { + LDKRouteHop *data; + uintptr_t datalen; +} LDKCVecTempl_RouteHop; + +typedef struct LDKCVecTempl_CVecTempl_RouteHop { + LDKCVecTempl_RouteHop *data; + uintptr_t datalen; +} LDKCVecTempl_CVecTempl_RouteHop; + +typedef LDKCVecTempl_CVecTempl_RouteHop LDKCVec_CVec_RouteHopZZ; + + + +/** + * A channel descriptor which provides a last-hop route to get_route + */ +typedef struct MUST_USE_STRUCT LDKRouteHint { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeRouteHint *inner; + bool is_owned; +} LDKRouteHint; + + + +/** + * Fees for routing via a given channel or a node + */ +typedef struct MUST_USE_STRUCT LDKRoutingFees { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeRoutingFees *inner; + bool is_owned; +} LDKRoutingFees; + +typedef union LDKCResultPtr_Route__LightningError { + LDKRoute *result; + LDKLightningError *err; +} LDKCResultPtr_Route__LightningError; + +typedef struct LDKCResultTempl_Route__LightningError { + LDKCResultPtr_Route__LightningError contents; + bool result_ok; +} LDKCResultTempl_Route__LightningError; + +typedef LDKCResultTempl_Route__LightningError LDKCResult_RouteLightningErrorZ; + + + +/** + * Represents the network as nodes and channels between them + */ +typedef struct MUST_USE_STRUCT LDKNetworkGraph { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNetworkGraph *inner; + bool is_owned; +} LDKNetworkGraph; + +typedef struct LDKCVecTempl_RouteHint { + LDKRouteHint *data; + uintptr_t datalen; +} LDKCVecTempl_RouteHint; + +typedef LDKCVecTempl_RouteHint LDKCVec_RouteHintZ; + + + +/** + * A simple newtype for RwLockReadGuard<'a, NetworkGraph>. + * This exists only to make accessing a RwLock possible from + * the C bindings, as it can be done directly in Rust code. + */ +typedef struct MUST_USE_STRUCT LDKLockedNetworkGraph { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeLockedNetworkGraph *inner; + bool is_owned; +} LDKLockedNetworkGraph; + + + +/** + * Receives and validates network updates from peers, + * stores authentic and relevant data as a network graph. + * This network graph is then used for routing payments. + * Provides interface to help with initial routing sync by + * serving historical announcements. + */ +typedef struct MUST_USE_STRUCT LDKNetGraphMsgHandler { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNetGraphMsgHandler *inner; + bool is_owned; +} LDKNetGraphMsgHandler; + + + +/** + * Details about one direction of a channel. Received + * within a channel update. + */ +typedef struct MUST_USE_STRUCT LDKDirectionalChannelInfo { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeDirectionalChannelInfo *inner; + bool is_owned; +} LDKDirectionalChannelInfo; + + + +/** + * Details about a channel (both directions). + * Received within a channel announcement. + */ +typedef struct MUST_USE_STRUCT LDKChannelInfo { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeChannelInfo *inner; + bool is_owned; +} LDKChannelInfo; + + + +/** + * Information received in the latest node_announcement from this node. + */ +typedef struct MUST_USE_STRUCT LDKNodeAnnouncementInfo { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNodeAnnouncementInfo *inner; + bool is_owned; +} LDKNodeAnnouncementInfo; + + + +/** + * Details about a node in the network, known from the network announcement. + */ +typedef struct MUST_USE_STRUCT LDKNodeInfo { + /** + * Nearly everyhwere, inner must be non-null, however in places where + * the Rust equivalent takes an Option, it may be set to null to indicate None. + */ + LDKnativeNodeInfo *inner; + bool is_owned; +} LDKNodeInfo; + +typedef struct LDKCVecTempl_u64 { + uint64_t *data; + uintptr_t datalen; +} LDKCVecTempl_u64; + +typedef LDKCVecTempl_u64 LDKCVec_u64Z; + +typedef LDKCVecTempl_RouteHop LDKCVec_RouteHopZ; + +extern const void (*C2Tuple_HTLCOutputInCommitmentSignatureZ_free)(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ); + +extern const void (*C2Tuple_OutPointScriptZ_free)(LDKC2Tuple_OutPointScriptZ); + +extern const void (*C2Tuple_Scriptu64Z_free)(LDKC2Tuple_Scriptu64Z); + +extern const void (*C2Tuple_SignatureCVec_SignatureZZ_free)(LDKC2Tuple_SignatureCVec_SignatureZZ); + +extern const void (*C2Tuple_Txidu32Z_free)(LDKC2Tuple_Txidu32Z); + +extern const void (*C2Tuple_u64u64Z_free)(LDKC2Tuple_u64u64Z); + +extern const void (*C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free)(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ); + +extern const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ (*CResult_C2Tuple_Scriptu64ZChainErrorZ_err)(LDKChainError); + +extern const void (*CResult_C2Tuple_Scriptu64ZChainErrorZ_free)(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ); + +extern const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ (*CResult_C2Tuple_Scriptu64ZChainErrorZ_ok)(LDKC2Tuple_Scriptu64Z); + +extern const void (*CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free)(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ); + +extern const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ (*CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok)(LDKC2Tuple_SignatureCVec_SignatureZZ); + +extern const void (*CResult_CVec_SignatureZNoneZ_free)(LDKCResult_CVec_SignatureZNoneZ); + +extern const LDKCResult_CVec_SignatureZNoneZ (*CResult_CVec_SignatureZNoneZ_ok)(LDKCVec_SignatureZ); + +extern const LDKCResult_CVec_u8ZPeerHandleErrorZ (*CResult_CVec_u8ZPeerHandleErrorZ_err)(LDKPeerHandleError); + +extern const void (*CResult_CVec_u8ZPeerHandleErrorZ_free)(LDKCResult_CVec_u8ZPeerHandleErrorZ); + +extern const LDKCResult_CVec_u8ZPeerHandleErrorZ (*CResult_CVec_u8ZPeerHandleErrorZ_ok)(LDKCVec_u8Z); + +extern const LDKCResult_NoneAPIErrorZ (*CResult_NoneAPIErrorZ_err)(LDKAPIError); + +extern const void (*CResult_NoneAPIErrorZ_free)(LDKCResult_NoneAPIErrorZ); + +extern const LDKCResult_NoneChannelMonitorUpdateErrZ (*CResult_NoneChannelMonitorUpdateErrZ_err)(LDKChannelMonitorUpdateErr); + +extern const void (*CResult_NoneChannelMonitorUpdateErrZ_free)(LDKCResult_NoneChannelMonitorUpdateErrZ); + +extern const LDKCResult_NoneMonitorUpdateErrorZ (*CResult_NoneMonitorUpdateErrorZ_err)(LDKMonitorUpdateError); + +extern const void (*CResult_NoneMonitorUpdateErrorZ_free)(LDKCResult_NoneMonitorUpdateErrorZ); + +extern const LDKCResult_NonePaymentSendFailureZ (*CResult_NonePaymentSendFailureZ_err)(LDKPaymentSendFailure); + +extern const void (*CResult_NonePaymentSendFailureZ_free)(LDKCResult_NonePaymentSendFailureZ); + +extern const LDKCResult_NonePeerHandleErrorZ (*CResult_NonePeerHandleErrorZ_err)(LDKPeerHandleError); + +extern const void (*CResult_NonePeerHandleErrorZ_free)(LDKCResult_NonePeerHandleErrorZ); + +extern const LDKCResult_PublicKeySecpErrorZ (*CResult_PublicKeySecpErrorZ_err)(LDKSecp256k1Error); + +extern const void (*CResult_PublicKeySecpErrorZ_free)(LDKCResult_PublicKeySecpErrorZ); + +extern const LDKCResult_PublicKeySecpErrorZ (*CResult_PublicKeySecpErrorZ_ok)(LDKPublicKey); + +extern const LDKCResult_RouteLightningErrorZ (*CResult_RouteLightningErrorZ_err)(LDKLightningError); + +extern const void (*CResult_RouteLightningErrorZ_free)(LDKCResult_RouteLightningErrorZ); + +extern const LDKCResult_RouteLightningErrorZ (*CResult_RouteLightningErrorZ_ok)(LDKRoute); + +extern const LDKCResult_SecretKeySecpErrorZ (*CResult_SecretKeySecpErrorZ_err)(LDKSecp256k1Error); + +extern const void (*CResult_SecretKeySecpErrorZ_free)(LDKCResult_SecretKeySecpErrorZ); + +extern const LDKCResult_SecretKeySecpErrorZ (*CResult_SecretKeySecpErrorZ_ok)(LDKSecretKey); + +extern const void (*CResult_SignatureNoneZ_free)(LDKCResult_SignatureNoneZ); + +extern const LDKCResult_SignatureNoneZ (*CResult_SignatureNoneZ_ok)(LDKSignature); + +extern const LDKCResult_TxCreationKeysSecpErrorZ (*CResult_TxCreationKeysSecpErrorZ_err)(LDKSecp256k1Error); + +extern const void (*CResult_TxCreationKeysSecpErrorZ_free)(LDKCResult_TxCreationKeysSecpErrorZ); + +extern const LDKCResult_TxCreationKeysSecpErrorZ (*CResult_TxCreationKeysSecpErrorZ_ok)(LDKTxCreationKeys); + +extern const LDKCResult_boolLightningErrorZ (*CResult_boolLightningErrorZ_err)(LDKLightningError); + +extern const void (*CResult_boolLightningErrorZ_free)(LDKCResult_boolLightningErrorZ); + +extern const LDKCResult_boolLightningErrorZ (*CResult_boolLightningErrorZ_ok)(bool); + +extern const LDKCResult_boolPeerHandleErrorZ (*CResult_boolPeerHandleErrorZ_err)(LDKPeerHandleError); + +extern const void (*CResult_boolPeerHandleErrorZ_free)(LDKCResult_boolPeerHandleErrorZ); + +extern const LDKCResult_boolPeerHandleErrorZ (*CResult_boolPeerHandleErrorZ_ok)(bool); + +extern const void (*CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ_free)(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ); + +extern const void (*CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free)(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ); + +extern const void (*CVec_CVec_RouteHopZZ_free)(LDKCVec_CVec_RouteHopZZ); + +extern const void (*CVec_ChannelDetailsZ_free)(LDKCVec_ChannelDetailsZ); + +extern const void (*CVec_ChannelMonitorZ_free)(LDKCVec_ChannelMonitorZ); + +extern const void (*CVec_EventZ_free)(LDKCVec_EventZ); + +extern const void (*CVec_HTLCOutputInCommitmentZ_free)(LDKCVec_HTLCOutputInCommitmentZ); + +extern const void (*CVec_MessageSendEventZ_free)(LDKCVec_MessageSendEventZ); + +extern const void (*CVec_MonitorEventZ_free)(LDKCVec_MonitorEventZ); + +extern const void (*CVec_NetAddressZ_free)(LDKCVec_NetAddressZ); + +extern const void (*CVec_NodeAnnouncementZ_free)(LDKCVec_NodeAnnouncementZ); + +extern const void (*CVec_PublicKeyZ_free)(LDKCVec_PublicKeyZ); + +extern const void (*CVec_RouteHintZ_free)(LDKCVec_RouteHintZ); + +extern const void (*CVec_RouteHopZ_free)(LDKCVec_RouteHopZ); + +extern const void (*CVec_SignatureZ_free)(LDKCVec_SignatureZ); + +extern const void (*CVec_SpendableOutputDescriptorZ_free)(LDKCVec_SpendableOutputDescriptorZ); + +extern const void (*CVec_TransactionZ_free)(LDKCVec_TransactionZ); + +extern const void (*CVec_UpdateAddHTLCZ_free)(LDKCVec_UpdateAddHTLCZ); + +extern const void (*CVec_UpdateFailHTLCZ_free)(LDKCVec_UpdateFailHTLCZ); + +extern const void (*CVec_UpdateFailMalformedHTLCZ_free)(LDKCVec_UpdateFailMalformedHTLCZ); + +extern const void (*CVec_UpdateFulfillHTLCZ_free)(LDKCVec_UpdateFulfillHTLCZ); + +extern const void (*CVec_u64Z_free)(LDKCVec_u64Z); + +extern const void (*CVec_u8Z_free)(LDKCVec_u8Z); + +extern const void (*CVec_usizeZ_free)(LDKCVec_usizeZ); + +extern const uint64_t MIN_RELAY_FEE_SAT_PER_1000_WEIGHT; + +void TxOut_free(LDKTxOut _res); + +LDKC2Tuple_Txidu32Z C2Tuple_Txidu32Z_new(LDKThirtyTwoBytes a, uint32_t b); + +LDKC2Tuple_Scriptu64Z C2Tuple_Scriptu64Z_new(LDKCVec_u8Z a, uint64_t b); + +LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b); + +LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(LDKSignature a, LDKCVec_SignatureZ b); + +LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void); + +LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void); + +LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void); + +LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void); + +LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void); + +LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void); + +LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void); + +LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(LDKOutPoint a, LDKCVec_u8Z b); + +LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(LDKChannelAnnouncement a, LDKChannelUpdate b, LDKChannelUpdate c); + +LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void); + +LDKC2Tuple_HTLCOutputInCommitmentSignatureZ C2Tuple_HTLCOutputInCommitmentSignatureZ_new(LDKHTLCOutputInCommitment a, LDKSignature b); + +void Event_free(LDKEvent this_ptr); + +void MessageSendEvent_free(LDKMessageSendEvent this_ptr); + +/** + * Calls the free function if one is set + */ +void MessageSendEventsProvider_free(LDKMessageSendEventsProvider this_ptr); + +/** + * Calls the free function if one is set + */ +void EventsProvider_free(LDKEventsProvider this_ptr); + +void APIError_free(LDKAPIError this_ptr); + +/** + * Returns the most verbose logging level. + */ +MUST_USE_RES LDKLevel Level_max(void); + +/** + * Calls the free function if one is set + */ +void Logger_free(LDKLogger this_ptr); + +void ChannelHandshakeConfig_free(LDKChannelHandshakeConfig this_ptr); + +/** + * Confirmations we will wait for before considering the channel locked in. + * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the + * equivalent limit applied to outbound channels). + * + * Default value: 6. + */ +uint32_t ChannelHandshakeConfig_get_minimum_depth(const LDKChannelHandshakeConfig *this_ptr); + +/** + * Confirmations we will wait for before considering the channel locked in. + * Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the + * equivalent limit applied to outbound channels). + * + * Default value: 6. + */ +void ChannelHandshakeConfig_set_minimum_depth(LDKChannelHandshakeConfig *this_ptr, uint32_t val); + +/** + * Set to the amount of time we require our counterparty to wait to claim their money. + * + * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST + * be online to check for peer having broadcast a revoked transaction to steal our funds + * at least once every our_to_self_delay blocks. + * + * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in + * case of an honest unilateral channel close, which implicitly decrease the economic value of + * our channel. + * + * Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel + * opening so you can tweak config to ask for more security, not less. + */ +uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const LDKChannelHandshakeConfig *this_ptr); + +/** + * Set to the amount of time we require our counterparty to wait to claim their money. + * + * It's one of the main parameter of our security model. We (or one of our watchtowers) MUST + * be online to check for peer having broadcast a revoked transaction to steal our funds + * at least once every our_to_self_delay blocks. + * + * Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in + * case of an honest unilateral channel close, which implicitly decrease the economic value of + * our channel. + * + * Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel + * opening so you can tweak config to ask for more security, not less. + */ +void ChannelHandshakeConfig_set_our_to_self_delay(LDKChannelHandshakeConfig *this_ptr, uint16_t val); + +/** + * Set to the smallest value HTLC we will accept to process. + * + * This value is sent to our counterparty on channel-open and we close the channel any time + * our counterparty misbehaves by sending us an HTLC with a value smaller than this. + * + * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required + * by the protocol. + */ +uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const LDKChannelHandshakeConfig *this_ptr); + +/** + * Set to the smallest value HTLC we will accept to process. + * + * This value is sent to our counterparty on channel-open and we close the channel any time + * our counterparty misbehaves by sending us an HTLC with a value smaller than this. + * + * Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required + * by the protocol. + */ +void ChannelHandshakeConfig_set_our_htlc_minimum_msat(LDKChannelHandshakeConfig *this_ptr, uint64_t val); + +MUST_USE_RES LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg); + +MUST_USE_RES LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void); + +void ChannelHandshakeLimits_free(LDKChannelHandshakeLimits this_ptr); + +/** + * Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so + * only applies to inbound channels. + * + * Default value: 0. + */ +uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so + * only applies to inbound channels. + * + * Default value: 0. + */ +void ChannelHandshakeLimits_set_min_funding_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows + * you to limit the maximum minimum-size they can require. + * + * Default value: u64::max_value. + */ +uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const LDKChannelHandshakeLimits *this_ptr); + +/** + * The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows + * you to limit the maximum minimum-size they can require. + * + * Default value: u64::max_value. + */ +void ChannelHandshakeLimits_set_max_htlc_minimum_msat(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * The remote node sets a limit on the maximum value of pending HTLCs to them at any given + * time to limit their funds exposure to HTLCs. This allows you to set a minimum such value. + * + * Default value: 0. + */ +uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const LDKChannelHandshakeLimits *this_ptr); + +/** + * The remote node sets a limit on the maximum value of pending HTLCs to them at any given + * time to limit their funds exposure to HTLCs. This allows you to set a minimum such value. + * + * Default value: 0. + */ +void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * The remote node will require we keep a certain amount in direct payment to ourselves at all + * time, ensuring that we are able to be punished if we broadcast an old state. This allows to + * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs). + * + * Default value: u64::max_value. + */ +uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const LDKChannelHandshakeLimits *this_ptr); + +/** + * The remote node will require we keep a certain amount in direct payment to ourselves at all + * time, ensuring that we are able to be punished if we broadcast an old state. This allows to + * you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs). + * + * Default value: u64::max_value. + */ +void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * The remote node sets a limit on the maximum number of pending HTLCs to them at any given + * time. This allows you to set a minimum such value. + * + * Default value: 0. + */ +uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const LDKChannelHandshakeLimits *this_ptr); + +/** + * The remote node sets a limit on the maximum number of pending HTLCs to them at any given + * time. This allows you to set a minimum such value. + * + * Default value: 0. + */ +void ChannelHandshakeLimits_set_min_max_accepted_htlcs(LDKChannelHandshakeLimits *this_ptr, uint16_t val); + +/** + * Outputs below a certain value will not be added to on-chain transactions. The dust value is + * required to always be higher than this value so this only applies to HTLC outputs (and + * potentially to-self outputs before any payments have been made). + * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. + * This setting allows you to set a minimum dust limit for their commitment transactions, + * reflecting the reality that tiny outputs are not considered standard transactions and will + * not propagate through the Bitcoin network. + * + * Default value: 546, the current dust limit on the Bitcoin network. + */ +uint64_t ChannelHandshakeLimits_get_min_dust_limit_satoshis(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Outputs below a certain value will not be added to on-chain transactions. The dust value is + * required to always be higher than this value so this only applies to HTLC outputs (and + * potentially to-self outputs before any payments have been made). + * Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. + * This setting allows you to set a minimum dust limit for their commitment transactions, + * reflecting the reality that tiny outputs are not considered standard transactions and will + * not propagate through the Bitcoin network. + * + * Default value: 546, the current dust limit on the Bitcoin network. + */ +void ChannelHandshakeLimits_set_min_dust_limit_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * Maximum allowed threshold above which outputs will not be generated in their commitment + * transactions. + * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. + * + * Default value: u64::max_value. + */ +uint64_t ChannelHandshakeLimits_get_max_dust_limit_satoshis(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Maximum allowed threshold above which outputs will not be generated in their commitment + * transactions. + * HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. + * + * Default value: u64::max_value. + */ +void ChannelHandshakeLimits_set_max_dust_limit_satoshis(LDKChannelHandshakeLimits *this_ptr, uint64_t val); + +/** + * Before a channel is usable the funding transaction will need to be confirmed by at least a + * certain number of blocks, specified by the node which is not the funder (as the funder can + * assume they aren't going to double-spend themselves). + * This config allows you to set a limit on the maximum amount of time to wait. + * + * Default value: 144, or roughly one day and only applies to outbound channels. + */ +uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Before a channel is usable the funding transaction will need to be confirmed by at least a + * certain number of blocks, specified by the node which is not the funder (as the funder can + * assume they aren't going to double-spend themselves). + * This config allows you to set a limit on the maximum amount of time to wait. + * + * Default value: 144, or roughly one day and only applies to outbound channels. + */ +void ChannelHandshakeLimits_set_max_minimum_depth(LDKChannelHandshakeLimits *this_ptr, uint32_t val); + +/** + * Set to force the incoming channel to match our announced channel preference in + * ChannelConfig. + * + * Default value: true, to make the default that no announced channels are possible (which is + * appropriate for any nodes which are not online very reliably). + */ +bool ChannelHandshakeLimits_get_force_announced_channel_preference(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Set to force the incoming channel to match our announced channel preference in + * ChannelConfig. + * + * Default value: true, to make the default that no announced channels are possible (which is + * appropriate for any nodes which are not online very reliably). + */ +void ChannelHandshakeLimits_set_force_announced_channel_preference(LDKChannelHandshakeLimits *this_ptr, bool val); + +/** + * Set to the amount of time we're willing to wait to claim money back to us. + * + * Not checking this value would be a security issue, as our peer would be able to set it to + * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time. + * + * Default value: MAX_LOCAL_BREAKDOWN_TIMEOUT (1008), which we also enforce as a maximum value + * so you can tweak config to reduce the loss of having useless locked funds (if your peer accepts) + */ +uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const LDKChannelHandshakeLimits *this_ptr); + +/** + * Set to the amount of time we're willing to wait to claim money back to us. + * + * Not checking this value would be a security issue, as our peer would be able to set it to + * max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time. + * + * Default value: MAX_LOCAL_BREAKDOWN_TIMEOUT (1008), which we also enforce as a maximum value + * so you can tweak config to reduce the loss of having useless locked funds (if your peer accepts) + */ +void ChannelHandshakeLimits_set_their_to_self_delay(LDKChannelHandshakeLimits *this_ptr, uint16_t val); + +MUST_USE_RES LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_htlc_minimum_msat_arg, uint64_t min_max_htlc_value_in_flight_msat_arg, uint64_t max_channel_reserve_satoshis_arg, uint16_t min_max_accepted_htlcs_arg, uint64_t min_dust_limit_satoshis_arg, uint64_t max_dust_limit_satoshis_arg, uint32_t max_minimum_depth_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg); + +MUST_USE_RES LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void); + +void ChannelConfig_free(LDKChannelConfig this_ptr); + +/** + * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi. + * This may be allowed to change at runtime in a later update, however doing so must result in + * update messages sent to notify all nodes of our updated relay fee. + * + * Default value: 0. + */ +uint32_t ChannelConfig_get_fee_proportional_millionths(const LDKChannelConfig *this_ptr); + +/** + * Amount (in millionths of a satoshi) the channel will charge per transferred satoshi. + * This may be allowed to change at runtime in a later update, however doing so must result in + * update messages sent to notify all nodes of our updated relay fee. + * + * Default value: 0. + */ +void ChannelConfig_set_fee_proportional_millionths(LDKChannelConfig *this_ptr, uint32_t val); + +/** + * Set to announce the channel publicly and notify all nodes that they can route via this + * channel. + * + * This should only be set to true for nodes which expect to be online reliably. + * + * As the node which funds a channel picks this value this will only apply for new outbound + * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set. + * + * This cannot be changed after the initial channel handshake. + * + * Default value: false. + */ +bool ChannelConfig_get_announced_channel(const LDKChannelConfig *this_ptr); + +/** + * Set to announce the channel publicly and notify all nodes that they can route via this + * channel. + * + * This should only be set to true for nodes which expect to be online reliably. + * + * As the node which funds a channel picks this value this will only apply for new outbound + * channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set. + * + * This cannot be changed after the initial channel handshake. + * + * Default value: false. + */ +void ChannelConfig_set_announced_channel(LDKChannelConfig *this_ptr, bool val); + +/** + * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty + * supports it, they will then enforce the mutual-close output to us matches what we provided + * at intialization, preventing us from closing to an alternate pubkey. + * + * This is set to true by default to provide a slight increase in security, though ultimately + * any attacker who is able to take control of a channel can just as easily send the funds via + * lightning payments, so we never require that our counterparties support this option. + * + * This cannot be changed after a channel has been initialized. + * + * Default value: true. + */ +bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const LDKChannelConfig *this_ptr); + +/** + * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty + * supports it, they will then enforce the mutual-close output to us matches what we provided + * at intialization, preventing us from closing to an alternate pubkey. + * + * This is set to true by default to provide a slight increase in security, though ultimately + * any attacker who is able to take control of a channel can just as easily send the funds via + * lightning payments, so we never require that our counterparties support this option. + * + * This cannot be changed after a channel has been initialized. + * + * Default value: true. + */ +void ChannelConfig_set_commit_upfront_shutdown_pubkey(LDKChannelConfig *this_ptr, bool val); + +MUST_USE_RES LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg); + +MUST_USE_RES LDKChannelConfig ChannelConfig_default(void); + +LDKCVec_u8Z ChannelConfig_write(const LDKChannelConfig *obj); + +LDKChannelConfig ChannelConfig_read(LDKu8slice ser); + +void UserConfig_free(LDKUserConfig this_ptr); + +/** + * Channel config that we propose to our counterparty. + */ +LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const LDKUserConfig *this_ptr); + +/** + * Channel config that we propose to our counterparty. + */ +void UserConfig_set_own_channel_config(LDKUserConfig *this_ptr, LDKChannelHandshakeConfig val); + +/** + * Limits applied to our counterparty's proposed channel config settings. + */ +LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const LDKUserConfig *this_ptr); + +/** + * Limits applied to our counterparty's proposed channel config settings. + */ +void UserConfig_set_peer_channel_config_limits(LDKUserConfig *this_ptr, LDKChannelHandshakeLimits val); + +/** + * Channel config which affects behavior during channel lifetime. + */ +LDKChannelConfig UserConfig_get_channel_options(const LDKUserConfig *this_ptr); + +/** + * Channel config which affects behavior during channel lifetime. + */ +void UserConfig_set_channel_options(LDKUserConfig *this_ptr, LDKChannelConfig val); + +MUST_USE_RES LDKUserConfig UserConfig_new(LDKChannelHandshakeConfig own_channel_config_arg, LDKChannelHandshakeLimits peer_channel_config_limits_arg, LDKChannelConfig channel_options_arg); + +MUST_USE_RES LDKUserConfig UserConfig_default(void); + +/** + * Calls the free function if one is set + */ +void ChainWatchInterface_free(LDKChainWatchInterface this_ptr); + +/** + * Calls the free function if one is set + */ +void BroadcasterInterface_free(LDKBroadcasterInterface this_ptr); + +/** + * Calls the free function if one is set + */ +void ChainListener_free(LDKChainListener this_ptr); + +/** + * Calls the free function if one is set + */ +void FeeEstimator_free(LDKFeeEstimator this_ptr); + +void ChainWatchedUtil_free(LDKChainWatchedUtil this_ptr); + +/** + * Constructs an empty (watches nothing) ChainWatchedUtil + */ +MUST_USE_RES LDKChainWatchedUtil ChainWatchedUtil_new(void); + +/** + * Registers a tx for monitoring, returning true if it was a new tx and false if we'd already + * been watching for it. + */ +MUST_USE_RES bool ChainWatchedUtil_register_tx(LDKChainWatchedUtil *this_arg, const uint8_t (*txid)[32], LDKu8slice script_pub_key); + +/** + * Registers an outpoint for monitoring, returning true if it was a new outpoint and false if + * we'd already been watching for it + */ +MUST_USE_RES bool ChainWatchedUtil_register_outpoint(LDKChainWatchedUtil *this_arg, LDKC2Tuple_Txidu32Z outpoint, LDKu8slice _script_pub_key); + +/** + * Sets us to match all transactions, returning true if this is a new setting and false if + * we'd already been set to match everything. + */ +MUST_USE_RES bool ChainWatchedUtil_watch_all(LDKChainWatchedUtil *this_arg); + +/** + * Checks if a given transaction matches the current filter. + */ +MUST_USE_RES bool ChainWatchedUtil_does_match_tx(const LDKChainWatchedUtil *this_arg, LDKTransaction tx); + +void BlockNotifier_free(LDKBlockNotifier this_ptr); + +/** + * Constructs a new BlockNotifier without any listeners. + */ +MUST_USE_RES LDKBlockNotifier BlockNotifier_new(LDKChainWatchInterface chain_monitor); + +/** + * Register the given listener to receive events. + */ +void BlockNotifier_register_listener(const LDKBlockNotifier *this_arg, LDKChainListener listener); + +/** + * Notify listeners that a block was connected given a full, unfiltered block. + * + * Handles re-scanning the block and calling block_connected again if listeners register new + * watch data during the callbacks for you (see ChainListener::block_connected for more info). + */ +void BlockNotifier_block_connected(const LDKBlockNotifier *this_arg, LDKu8slice block, uint32_t height); + +/** + * Notify listeners that a block was connected, given pre-filtered list of transactions in the + * block which matched the filter (probably using does_match_tx). + * + * Returns true if notified listeners registered additional watch data (implying that the + * block must be re-scanned and this function called again prior to further block_connected + * calls, see ChainListener::block_connected for more info). + */ +MUST_USE_RES bool BlockNotifier_block_connected_checked(const LDKBlockNotifier *this_arg, const uint8_t (*header)[80], uint32_t height, LDKCVec_TransactionZ txn_matched, LDKusizeslice indexes_of_txn_matched); + +/** + * Notify listeners that a block was disconnected. + */ +void BlockNotifier_block_disconnected(const LDKBlockNotifier *this_arg, const uint8_t (*header)[80], uint32_t disconnected_height); + +void ChainWatchInterfaceUtil_free(LDKChainWatchInterfaceUtil this_ptr); + +LDKChainWatchInterface ChainWatchInterfaceUtil_as_ChainWatchInterface(const LDKChainWatchInterfaceUtil *this_arg); + +/** + * Creates a new ChainWatchInterfaceUtil for the given network + */ +MUST_USE_RES LDKChainWatchInterfaceUtil ChainWatchInterfaceUtil_new(LDKNetwork network); + +/** + * Checks if a given transaction matches the current filter. + */ +MUST_USE_RES bool ChainWatchInterfaceUtil_does_match_tx(const LDKChainWatchInterfaceUtil *this_arg, LDKTransaction tx); + +void OutPoint_free(LDKOutPoint this_ptr); + +/** + * The referenced transaction's txid. + */ +const uint8_t (*OutPoint_get_txid(const LDKOutPoint *this_ptr))[32]; + +/** + * The referenced transaction's txid. + */ +void OutPoint_set_txid(LDKOutPoint *this_ptr, LDKThirtyTwoBytes val); + +/** + * The index of the referenced output in its transaction's vout. + */ +uint16_t OutPoint_get_index(const LDKOutPoint *this_ptr); + +/** + * The index of the referenced output in its transaction's vout. + */ +void OutPoint_set_index(LDKOutPoint *this_ptr, uint16_t val); + +MUST_USE_RES LDKOutPoint OutPoint_new(LDKThirtyTwoBytes txid_arg, uint16_t index_arg); + +/** + * Convert an `OutPoint` to a lightning channel id. + */ +MUST_USE_RES LDKThirtyTwoBytes OutPoint_to_channel_id(const LDKOutPoint *this_arg); + +LDKCVec_u8Z OutPoint_write(const LDKOutPoint *obj); + +LDKOutPoint OutPoint_read(LDKu8slice ser); + +void SpendableOutputDescriptor_free(LDKSpendableOutputDescriptor this_ptr); + +/** + * Calls the free function if one is set + */ +void ChannelKeys_free(LDKChannelKeys this_ptr); + +/** + * Calls the free function if one is set + */ +void KeysInterface_free(LDKKeysInterface this_ptr); + +void InMemoryChannelKeys_free(LDKInMemoryChannelKeys this_ptr); + +/** + * Private key of anchor tx + */ +const uint8_t (*InMemoryChannelKeys_get_funding_key(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Private key of anchor tx + */ +void InMemoryChannelKeys_set_funding_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val); + +/** + * Local secret key for blinded revocation pubkey + */ +const uint8_t (*InMemoryChannelKeys_get_revocation_base_key(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Local secret key for blinded revocation pubkey + */ +void InMemoryChannelKeys_set_revocation_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val); + +/** + * Local secret key used for our balance in remote-broadcasted commitment transactions + */ +const uint8_t (*InMemoryChannelKeys_get_payment_key(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Local secret key used for our balance in remote-broadcasted commitment transactions + */ +void InMemoryChannelKeys_set_payment_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val); + +/** + * Local secret key used in HTLC tx + */ +const uint8_t (*InMemoryChannelKeys_get_delayed_payment_base_key(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Local secret key used in HTLC tx + */ +void InMemoryChannelKeys_set_delayed_payment_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val); + +/** + * Local htlc secret key used in commitment tx htlc outputs + */ +const uint8_t (*InMemoryChannelKeys_get_htlc_base_key(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Local htlc secret key used in commitment tx htlc outputs + */ +void InMemoryChannelKeys_set_htlc_base_key(LDKInMemoryChannelKeys *this_ptr, LDKSecretKey val); + +/** + * Commitment seed + */ +const uint8_t (*InMemoryChannelKeys_get_commitment_seed(const LDKInMemoryChannelKeys *this_ptr))[32]; + +/** + * Commitment seed + */ +void InMemoryChannelKeys_set_commitment_seed(LDKInMemoryChannelKeys *this_ptr, LDKThirtyTwoBytes val); + +/** + * Create a new InMemoryChannelKeys + */ +MUST_USE_RES LDKInMemoryChannelKeys InMemoryChannelKeys_new(LDKSecretKey funding_key, LDKSecretKey revocation_base_key, LDKSecretKey payment_key, LDKSecretKey delayed_payment_base_key, LDKSecretKey htlc_base_key, LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, LDKC2Tuple_u64u64Z key_derivation_params); + +/** + * Remote pubkeys. + * Will panic if on_accept wasn't called. + */ +MUST_USE_RES LDKChannelPublicKeys InMemoryChannelKeys_remote_pubkeys(const LDKInMemoryChannelKeys *this_arg); + +/** + * The to_self_delay value specified by our counterparty and applied on locally-broadcastable + * transactions, ie the amount of time that we have to wait to recover our funds if we + * broadcast a transaction. You'll likely want to pass this to the + * ln::chan_utils::build*_transaction functions when signing local transactions. + * Will panic if on_accept wasn't called. + */ +MUST_USE_RES uint16_t InMemoryChannelKeys_remote_to_self_delay(const LDKInMemoryChannelKeys *this_arg); + +/** + * The to_self_delay value specified by us and applied on transactions broadcastable + * by our counterparty, ie the amount of time that they have to wait to recover their funds + * if they broadcast a transaction. + * Will panic if on_accept wasn't called. + */ +MUST_USE_RES uint16_t InMemoryChannelKeys_local_to_self_delay(const LDKInMemoryChannelKeys *this_arg); + +LDKChannelKeys InMemoryChannelKeys_as_ChannelKeys(const LDKInMemoryChannelKeys *this_arg); + +LDKCVec_u8Z InMemoryChannelKeys_write(const LDKInMemoryChannelKeys *obj); + +LDKInMemoryChannelKeys InMemoryChannelKeys_read(LDKu8slice ser); + +void KeysManager_free(LDKKeysManager this_ptr); + +/** + * Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your + * CSRNG is busted) this may panic (but more importantly, you will possibly lose funds). + * starting_time isn't strictly required to actually be a time, but it must absolutely, + * without a doubt, be unique to this instance. ie if you start multiple times with the same + * seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to + * simply use the current time (with very high precision). + * + * The seed MUST be backed up safely prior to use so that the keys can be re-created, however, + * obviously, starting_time should be unique every time you reload the library - it is only + * used to generate new ephemeral key data (which will be stored by the individual channel if + * necessary). + * + * Note that the seed is required to recover certain on-chain funds independent of + * ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any + * channel, and some on-chain during-closing funds. + * + * Note that until the 0.1 release there is no guarantee of backward compatibility between + * versions. Once the library is more fully supported, the docs will be updated to include a + * detailed description of the guarantee. + */ +MUST_USE_RES LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], LDKNetwork network, uint64_t starting_time_secs, uint32_t starting_time_nanos); + +/** + * Derive an old set of ChannelKeys for per-channel secrets based on a key derivation + * parameters. + * Key derivation parameters are accessible through a per-channel secrets + * ChannelKeys::key_derivation_params and is provided inside DynamicOuputP2WSH in case of + * onchain output detection for which a corresponding delayed_payment_key must be derived. + */ +MUST_USE_RES LDKInMemoryChannelKeys KeysManager_derive_channel_keys(const LDKKeysManager *this_arg, uint64_t channel_value_satoshis, uint64_t params_1, uint64_t params_2); + +LDKKeysInterface KeysManager_as_KeysInterface(const LDKKeysManager *this_arg); + +void ChannelManager_free(LDKChannelManager this_ptr); + +void ChannelDetails_free(LDKChannelDetails this_ptr); + +/** + * The channel's ID (prior to funding transaction generation, this is a random 32 bytes, + * thereafter this is the txid of the funding transaction xor the funding transaction output). + * Note that this means this value is *not* persistent - it can change once during the + * lifetime of the channel. + */ +const uint8_t (*ChannelDetails_get_channel_id(const LDKChannelDetails *this_ptr))[32]; + +/** + * The channel's ID (prior to funding transaction generation, this is a random 32 bytes, + * thereafter this is the txid of the funding transaction xor the funding transaction output). + * Note that this means this value is *not* persistent - it can change once during the + * lifetime of the channel. + */ +void ChannelDetails_set_channel_id(LDKChannelDetails *this_ptr, LDKThirtyTwoBytes val); + +/** + * The node_id of our counterparty + */ +LDKPublicKey ChannelDetails_get_remote_network_id(const LDKChannelDetails *this_ptr); + +/** + * The node_id of our counterparty + */ +void ChannelDetails_set_remote_network_id(LDKChannelDetails *this_ptr, LDKPublicKey val); + +/** + * The Features the channel counterparty provided upon last connection. + * Useful for routing as it is the most up-to-date copy of the counterparty's features and + * many routing-relevant features are present in the init context. + */ +LDKInitFeatures ChannelDetails_get_counterparty_features(const LDKChannelDetails *this_ptr); + +/** + * The Features the channel counterparty provided upon last connection. + * Useful for routing as it is the most up-to-date copy of the counterparty's features and + * many routing-relevant features are present in the init context. + */ +void ChannelDetails_set_counterparty_features(LDKChannelDetails *this_ptr, LDKInitFeatures val); + +/** + * The value, in satoshis, of this channel as appears in the funding output + */ +uint64_t ChannelDetails_get_channel_value_satoshis(const LDKChannelDetails *this_ptr); + +/** + * The value, in satoshis, of this channel as appears in the funding output + */ +void ChannelDetails_set_channel_value_satoshis(LDKChannelDetails *this_ptr, uint64_t val); + +/** + * The user_id passed in to create_channel, or 0 if the channel was inbound. + */ +uint64_t ChannelDetails_get_user_id(const LDKChannelDetails *this_ptr); + +/** + * The user_id passed in to create_channel, or 0 if the channel was inbound. + */ +void ChannelDetails_set_user_id(LDKChannelDetails *this_ptr, uint64_t val); + +/** + * The available outbound capacity for sending HTLCs to the remote peer. This does not include + * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not + * available for inclusion in new outbound HTLCs). This further does not include any pending + * outgoing HTLCs which are awaiting some other resolution to be sent. + */ +uint64_t ChannelDetails_get_outbound_capacity_msat(const LDKChannelDetails *this_ptr); + +/** + * The available outbound capacity for sending HTLCs to the remote peer. This does not include + * any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not + * available for inclusion in new outbound HTLCs). This further does not include any pending + * outgoing HTLCs which are awaiting some other resolution to be sent. + */ +void ChannelDetails_set_outbound_capacity_msat(LDKChannelDetails *this_ptr, uint64_t val); + +/** + * The available inbound capacity for the remote peer to send HTLCs to us. This does not + * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not + * available for inclusion in new inbound HTLCs). + * Note that there are some corner cases not fully handled here, so the actual available + * inbound capacity may be slightly higher than this. + */ +uint64_t ChannelDetails_get_inbound_capacity_msat(const LDKChannelDetails *this_ptr); + +/** + * The available inbound capacity for the remote peer to send HTLCs to us. This does not + * include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not + * available for inclusion in new inbound HTLCs). + * Note that there are some corner cases not fully handled here, so the actual available + * inbound capacity may be slightly higher than this. + */ +void ChannelDetails_set_inbound_capacity_msat(LDKChannelDetails *this_ptr, uint64_t val); + +/** + * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b) + * the peer is connected, and (c) no monitor update failure is pending resolution. + */ +bool ChannelDetails_get_is_live(const LDKChannelDetails *this_ptr); + +/** + * True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b) + * the peer is connected, and (c) no monitor update failure is pending resolution. + */ +void ChannelDetails_set_is_live(LDKChannelDetails *this_ptr, bool val); + +void PaymentSendFailure_free(LDKPaymentSendFailure this_ptr); + +/** + * Constructs a new ChannelManager to hold several channels and route between them. + * + * This is the main \"logic hub\" for all channel-related actions, and implements + * ChannelMessageHandler. + * + * Non-proportional fees are fixed according to our risk using the provided fee estimator. + * + * panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`! + * + * Users must provide the current blockchain height from which to track onchain channel + * funding outpoints and send payments with reliable timelocks. + * + * Users need to notify the new ChannelManager when a new block is connected or + * disconnected using its `block_connected` and `block_disconnected` methods. + * However, rather than calling these methods directly, the user should register + * the ChannelManager as a listener to the BlockNotifier and call the BlockNotifier's + * `block_(dis)connected` methods, which will notify all registered listeners in one + * go. + */ +MUST_USE_RES LDKChannelManager ChannelManager_new(LDKNetwork network, LDKFeeEstimator fee_est, LDKManyChannelMonitor monitor, LDKBroadcasterInterface tx_broadcaster, LDKLogger logger, LDKKeysInterface keys_manager, LDKUserConfig config, uintptr_t current_blockchain_height); + +/** + * Creates a new outbound channel to the given remote node and with the given value. + * + * user_id will be provided back as user_channel_id in FundingGenerationReady and + * FundingBroadcastSafe events to allow tracking of which events correspond with which + * create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you + * may wish to avoid using 0 for user_id here. + * + * If successful, will generate a SendOpenChannel message event, so you should probably poll + * PeerManager::process_events afterwards. + * + * Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is + * greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000. + */ +MUST_USE_RES LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const LDKChannelManager *this_arg, LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, LDKUserConfig override_config); + +/** + * Gets the list of open channels, in random order. See ChannelDetail field documentation for + * more information. + */ +MUST_USE_RES LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const LDKChannelManager *this_arg); + +/** + * Gets the list of usable channels, in random order. Useful as an argument to + * get_route to ensure non-announced channels are used. + * + * These are guaranteed to have their is_live value set to true, see the documentation for + * ChannelDetails::is_live for more info on exactly what the criteria are. + */ +MUST_USE_RES LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const LDKChannelManager *this_arg); + +/** + * Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs + * will be accepted on the given channel, and after additional timeout/the closing of all + * pending HTLCs, the channel will be closed on chain. + * + * May generate a SendShutdown message event on success, which should be relayed. + */ +MUST_USE_RES LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const LDKChannelManager *this_arg, const uint8_t (*channel_id)[32]); + +/** + * Force closes a channel, immediately broadcasting the latest local commitment transaction to + * the chain and rejecting new HTLCs on the given channel. + */ +void ChannelManager_force_close_channel(const LDKChannelManager *this_arg, const uint8_t (*channel_id)[32]); + +/** + * Force close all channels, immediately broadcasting the latest local commitment transaction + * for each to the chain and rejecting new HTLCs on each. + */ +void ChannelManager_force_close_all_channels(const LDKChannelManager *this_arg); + +/** + * Sends a payment along a given route. + * + * Value parameters are provided via the last hop in route, see documentation for RouteHop + * fields for more info. + * + * Note that if the payment_hash already exists elsewhere (eg you're sending a duplicative + * payment), we don't do anything to stop you! We always try to ensure that if the provided + * next hop knows the preimage to payment_hash they can claim an additional amount as + * specified in the last hop in the route! Thus, you should probably do your own + * payment_preimage tracking (which you should already be doing as they represent \"proof of + * payment\") and prevent double-sends yourself. + * + * May generate SendHTLCs message(s) event on success, which should be relayed. + * + * Each path may have a different return value, and PaymentSendValue may return a Vec with + * each entry matching the corresponding-index entry in the route paths, see + * PaymentSendFailure for more info. + * + * In general, a path may raise: + * * APIError::RouteError when an invalid route or forwarding parameter (cltv_delta, fee, + * node public key) is specified. + * * APIError::ChannelUnavailable if the next-hop channel is not available for updates + * (including due to previous monitor update failure or new permanent monitor update + * failure). + * * APIError::MonitorUpdateFailed if a new monitor update failure prevented sending the + * relevant updates. + * + * Note that depending on the type of the PaymentSendFailure the HTLC may have been + * irrevocably committed to on our end. In such a case, do NOT retry the payment with a + * different route unless you intend to pay twice! + * + * payment_secret is unrelated to payment_hash (or PaymentPreimage) and exists to authenticate + * the sender to the recipient and prevent payment-probing (deanonymization) attacks. For + * newer nodes, it will be provided to you in the invoice. If you do not have one, the Route + * must not contain multiple paths as multi-path payments require a recipient-provided + * payment_secret. + * If a payment_secret *is* provided, we assume that the invoice had the payment_secret feature + * bit set (either as required or as available). If multiple paths are present in the Route, + * we assume the invoice had the basic_mpp feature set. + */ +MUST_USE_RES LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment(const LDKChannelManager *this_arg, const LDKRoute *route, LDKThirtyTwoBytes payment_hash, LDKThirtyTwoBytes payment_secret); + +/** + * Call this upon creation of a funding transaction for the given channel. + * + * Note that ALL inputs in the transaction pointed to by funding_txo MUST spend SegWit outputs + * or your counterparty can steal your funds! + * + * Panics if a funding transaction has already been provided for this channel. + * + * May panic if the funding_txo is duplicative with some other channel (note that this should + * be trivially prevented by using unique funding transaction keys per-channel). + */ +void ChannelManager_funding_transaction_generated(const LDKChannelManager *this_arg, const uint8_t (*temporary_channel_id)[32], LDKOutPoint funding_txo); + +/** + * Generates a signed node_announcement from the given arguments and creates a + * BroadcastNodeAnnouncement event. Note that such messages will be ignored unless peers have + * seen a channel_announcement from us (ie unless we have public channels open). + * + * RGB is a node \"color\" and alias is a printable human-readable string to describe this node + * to humans. They carry no in-protocol meaning. + * + * addresses represent the set (possibly empty) of socket addresses on which this node accepts + * incoming connections. These will be broadcast to the network, publicly tying these + * addresses together. If you wish to preserve user privacy, addresses should likely contain + * only Tor Onion addresses. + * + * Panics if addresses is absurdly large (more than 500). + */ +void ChannelManager_broadcast_node_announcement(const LDKChannelManager *this_arg, LDKThreeBytes rgb, LDKThirtyTwoBytes alias, LDKCVec_NetAddressZ addresses); + +/** + * Processes HTLCs which are pending waiting on random forward delay. + * + * Should only really ever be called in response to a PendingHTLCsForwardable event. + * Will likely generate further events. + */ +void ChannelManager_process_pending_htlc_forwards(const LDKChannelManager *this_arg); + +/** + * If a peer is disconnected we mark any channels with that peer as 'disabled'. + * After some time, if channels are still disabled we need to broadcast a ChannelUpdate + * to inform the network about the uselessness of these channels. + * + * This method handles all the details, and must be called roughly once per minute. + */ +void ChannelManager_timer_chan_freshness_every_min(const LDKChannelManager *this_arg); + +/** + * Indicates that the preimage for payment_hash is unknown or the received amount is incorrect + * after a PaymentReceived event, failing the HTLC back to its origin and freeing resources + * along the path (including in our own channel on which we received it). + * Returns false if no payment was found to fail backwards, true if the process of failing the + * HTLC backwards has been started. + */ +MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const LDKChannelManager *this_arg, const uint8_t (*payment_hash)[32], LDKThirtyTwoBytes payment_secret); + +/** + * Provides a payment preimage in response to a PaymentReceived event, returning true and + * generating message events for the net layer to claim the payment, if possible. Thus, you + * should probably kick the net layer to go send messages if this returns true! + * + * You must specify the expected amounts for this HTLC, and we will only claim HTLCs + * available within a few percent of the expected amount. This is critical for several + * reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the + * payment_preimage without having provided the full value and b) it avoids certain + * privacy-breaking recipient-probing attacks which may reveal payment activity to + * motivated attackers. + * + * Note that the privacy concerns in (b) are not relevant in payments with a payment_secret + * set. Thus, for such payments we will claim any payments which do not under-pay. + * + * May panic if called except in response to a PaymentReceived event. + */ +MUST_USE_RES bool ChannelManager_claim_funds(const LDKChannelManager *this_arg, LDKThirtyTwoBytes payment_preimage, LDKThirtyTwoBytes payment_secret, uint64_t expected_amount); + +/** + * Gets the node_id held by this ChannelManager + */ +MUST_USE_RES LDKPublicKey ChannelManager_get_our_node_id(const LDKChannelManager *this_arg); + +/** + * Restores a single, given channel to normal operation after a + * ChannelMonitorUpdateErr::TemporaryFailure was returned from a channel monitor update + * operation. + * + * All ChannelMonitor updates up to and including highest_applied_update_id must have been + * fully committed in every copy of the given channels' ChannelMonitors. + * + * Note that there is no effect to calling with a highest_applied_update_id other than the + * current latest ChannelMonitorUpdate and one call to this function after multiple + * ChannelMonitorUpdateErr::TemporaryFailures is fine. The highest_applied_update_id field + * exists largely only to prevent races between this and concurrent update_monitor calls. + * + * Thus, the anticipated use is, at a high level: + * 1) You register a ManyChannelMonitor with this ChannelManager, + * 2) it stores each update to disk, and begins updating any remote (eg watchtower) copies of + * said ChannelMonitors as it can, returning ChannelMonitorUpdateErr::TemporaryFailures + * any time it cannot do so instantly, + * 3) update(s) are applied to each remote copy of a ChannelMonitor, + * 4) once all remote copies are updated, you call this function with the update_id that + * completed, and once it is the latest the Channel will be re-enabled. + */ +void ChannelManager_channel_monitor_updated(const LDKChannelManager *this_arg, const LDKOutPoint *funding_txo, uint64_t highest_applied_update_id); + +LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const LDKChannelManager *this_arg); + +LDKEventsProvider ChannelManager_as_EventsProvider(const LDKChannelManager *this_arg); + +LDKChainListener ChannelManager_as_ChainListener(const LDKChannelManager *this_arg); + +LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const LDKChannelManager *this_arg); + +void ChannelManagerReadArgs_free(LDKChannelManagerReadArgs this_ptr); + +/** + * The keys provider which will give us relevant keys. Some keys will be loaded during + * deserialization. + */ +const LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const LDKChannelManagerReadArgs *this_ptr); + +/** + * The keys provider which will give us relevant keys. Some keys will be loaded during + * deserialization. + */ +void ChannelManagerReadArgs_set_keys_manager(LDKChannelManagerReadArgs *this_ptr, LDKKeysInterface val); + +/** + * The fee_estimator for use in the ChannelManager in the future. + * + * No calls to the FeeEstimator will be made during deserialization. + */ +const LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const LDKChannelManagerReadArgs *this_ptr); + +/** + * The fee_estimator for use in the ChannelManager in the future. + * + * No calls to the FeeEstimator will be made during deserialization. + */ +void ChannelManagerReadArgs_set_fee_estimator(LDKChannelManagerReadArgs *this_ptr, LDKFeeEstimator val); + +/** + * The ManyChannelMonitor for use in the ChannelManager in the future. + * + * No calls to the ManyChannelMonitor will be made during deserialization. It is assumed that + * you have deserialized ChannelMonitors separately and will add them to your + * ManyChannelMonitor after deserializing this ChannelManager. + */ +const LDKManyChannelMonitor *ChannelManagerReadArgs_get_monitor(const LDKChannelManagerReadArgs *this_ptr); + +/** + * The ManyChannelMonitor for use in the ChannelManager in the future. + * + * No calls to the ManyChannelMonitor will be made during deserialization. It is assumed that + * you have deserialized ChannelMonitors separately and will add them to your + * ManyChannelMonitor after deserializing this ChannelManager. + */ +void ChannelManagerReadArgs_set_monitor(LDKChannelManagerReadArgs *this_ptr, LDKManyChannelMonitor val); + +/** + * The BroadcasterInterface which will be used in the ChannelManager in the future and may be + * used to broadcast the latest local commitment transactions of channels which must be + * force-closed during deserialization. + */ +const LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const LDKChannelManagerReadArgs *this_ptr); + +/** + * The BroadcasterInterface which will be used in the ChannelManager in the future and may be + * used to broadcast the latest local commitment transactions of channels which must be + * force-closed during deserialization. + */ +void ChannelManagerReadArgs_set_tx_broadcaster(LDKChannelManagerReadArgs *this_ptr, LDKBroadcasterInterface val); + +/** + * The Logger for use in the ChannelManager and which may be used to log information during + * deserialization. + */ +const LDKLogger *ChannelManagerReadArgs_get_logger(const LDKChannelManagerReadArgs *this_ptr); + +/** + * The Logger for use in the ChannelManager and which may be used to log information during + * deserialization. + */ +void ChannelManagerReadArgs_set_logger(LDKChannelManagerReadArgs *this_ptr, LDKLogger val); + +/** + * Default settings used for new channels. Any existing channels will continue to use the + * runtime settings which were stored when the ChannelManager was serialized. + */ +LDKUserConfig ChannelManagerReadArgs_get_default_config(const LDKChannelManagerReadArgs *this_ptr); + +/** + * Default settings used for new channels. Any existing channels will continue to use the + * runtime settings which were stored when the ChannelManager was serialized. + */ +void ChannelManagerReadArgs_set_default_config(LDKChannelManagerReadArgs *this_ptr, LDKUserConfig val); + +/** + * Simple utility function to create a ChannelManagerReadArgs which creates the monitor + * HashMap for you. This is primarily useful for C bindings where it is not practical to + * populate a HashMap directly from C. + */ +MUST_USE_RES LDKChannelManagerReadArgs ChannelManagerReadArgs_new(LDKKeysInterface keys_manager, LDKFeeEstimator fee_estimator, LDKManyChannelMonitor monitor, LDKBroadcasterInterface tx_broadcaster, LDKLogger logger, LDKUserConfig default_config, LDKCVec_ChannelMonitorZ channel_monitors); + +void ChannelMonitorUpdate_free(LDKChannelMonitorUpdate this_ptr); + +/** + * The sequence number of this update. Updates *must* be replayed in-order according to this + * sequence number (and updates may panic if they are not). The update_id values are strictly + * increasing and increase by one for each new update. + * + * This sequence number is also used to track up to which points updates which returned + * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given + * ChannelMonitor when ChannelManager::channel_monitor_updated is called. + */ +uint64_t ChannelMonitorUpdate_get_update_id(const LDKChannelMonitorUpdate *this_ptr); + +/** + * The sequence number of this update. Updates *must* be replayed in-order according to this + * sequence number (and updates may panic if they are not). The update_id values are strictly + * increasing and increase by one for each new update. + * + * This sequence number is also used to track up to which points updates which returned + * ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given + * ChannelMonitor when ChannelManager::channel_monitor_updated is called. + */ +void ChannelMonitorUpdate_set_update_id(LDKChannelMonitorUpdate *this_ptr, uint64_t val); + +LDKCVec_u8Z ChannelMonitorUpdate_write(const LDKChannelMonitorUpdate *obj); + +LDKChannelMonitorUpdate ChannelMonitorUpdate_read(LDKu8slice ser); + +void MonitorUpdateError_free(LDKMonitorUpdateError this_ptr); + +void MonitorEvent_free(LDKMonitorEvent this_ptr); + +void HTLCUpdate_free(LDKHTLCUpdate this_ptr); + +LDKCVec_u8Z HTLCUpdate_write(const LDKHTLCUpdate *obj); + +LDKHTLCUpdate HTLCUpdate_read(LDKu8slice ser); + +void ChannelMonitor_free(LDKChannelMonitor this_ptr); + +/** + * Calls the free function if one is set + */ +void ManyChannelMonitor_free(LDKManyChannelMonitor this_ptr); + +/** + * Updates a ChannelMonitor on the basis of some new information provided by the Channel + * itself. + * + * panics if the given update is not the next update by update_id. + */ +MUST_USE_RES LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(LDKChannelMonitor *this_arg, LDKChannelMonitorUpdate updates, const LDKBroadcasterInterface *broadcaster, const LDKLogger *logger); + +/** + * Gets the update_id from the latest ChannelMonitorUpdate which was applied to this + * ChannelMonitor. + */ +MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const LDKChannelMonitor *this_arg); + +/** + * Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. + */ +MUST_USE_RES LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const LDKChannelMonitor *this_arg); + +/** + * Get the list of HTLCs who's status has been updated on chain. This should be called by + * ChannelManager via ManyChannelMonitor::get_and_clear_pending_monitor_events(). + */ +MUST_USE_RES LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(LDKChannelMonitor *this_arg); + +/** + * Gets the list of pending events which were generated by previous actions, clearing the list + * in the process. + * + * This is called by ManyChannelMonitor::get_and_clear_pending_events() and is equivalent to + * EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do + * no internal locking in ChannelMonitors. + */ +MUST_USE_RES LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(LDKChannelMonitor *this_arg); + +/** + * Used by ChannelManager deserialization to broadcast the latest local state if its copy of + * the Channel was out-of-date. You may use it to get a broadcastable local toxic tx in case of + * fallen-behind, i.e when receiving a channel_reestablish with a proof that our remote side knows + * a higher revocation secret than the local commitment number we are aware of. Broadcasting these + * transactions are UNSAFE, as they allow remote side to punish you. Nevertheless you may want to + * broadcast them if remote don't close channel with his higher commitment transaction after a + * substantial amount of time (a month or even a year) to get back funds. Best may be to contact + * out-of-band the other node operator to coordinate with him if option is available to you. + * In any-case, choice is up to the user. + */ +MUST_USE_RES LDKCVec_TransactionZ ChannelMonitor_get_latest_local_commitment_txn(LDKChannelMonitor *this_arg, const LDKLogger *logger); + +void DecodeError_free(LDKDecodeError this_ptr); + +void Init_free(LDKInit this_ptr); + +void ErrorMessage_free(LDKErrorMessage this_ptr); + +/** + * The channel ID involved in the error + */ +const uint8_t (*ErrorMessage_get_channel_id(const LDKErrorMessage *this_ptr))[32]; + +/** + * The channel ID involved in the error + */ +void ErrorMessage_set_channel_id(LDKErrorMessage *this_ptr, LDKThirtyTwoBytes val); + +/** + * A possibly human-readable error description. + * The string should be sanitized before it is used (e.g. emitted to logs + * or printed to stdout). Otherwise, a well crafted error message may trigger a security + * vulnerability in the terminal emulator or the logging subsystem. + */ +LDKStr ErrorMessage_get_data(const LDKErrorMessage *this_ptr); + +/** + * A possibly human-readable error description. + * The string should be sanitized before it is used (e.g. emitted to logs + * or printed to stdout). Otherwise, a well crafted error message may trigger a security + * vulnerability in the terminal emulator or the logging subsystem. + */ +void ErrorMessage_set_data(LDKErrorMessage *this_ptr, LDKCVec_u8Z val); + +MUST_USE_RES LDKErrorMessage ErrorMessage_new(LDKThirtyTwoBytes channel_id_arg, LDKCVec_u8Z data_arg); + +void Ping_free(LDKPing this_ptr); + +/** + * The desired response length + */ +uint16_t Ping_get_ponglen(const LDKPing *this_ptr); + +/** + * The desired response length + */ +void Ping_set_ponglen(LDKPing *this_ptr, uint16_t val); + +/** + * The ping packet size. + * This field is not sent on the wire. byteslen zeros are sent. + */ +uint16_t Ping_get_byteslen(const LDKPing *this_ptr); + +/** + * The ping packet size. + * This field is not sent on the wire. byteslen zeros are sent. + */ +void Ping_set_byteslen(LDKPing *this_ptr, uint16_t val); + +MUST_USE_RES LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg); + +void Pong_free(LDKPong this_ptr); + +/** + * The pong packet size. + * This field is not sent on the wire. byteslen zeros are sent. + */ +uint16_t Pong_get_byteslen(const LDKPong *this_ptr); + +/** + * The pong packet size. + * This field is not sent on the wire. byteslen zeros are sent. + */ +void Pong_set_byteslen(LDKPong *this_ptr, uint16_t val); + +MUST_USE_RES LDKPong Pong_new(uint16_t byteslen_arg); + +void OpenChannel_free(LDKOpenChannel this_ptr); + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +const uint8_t (*OpenChannel_get_chain_hash(const LDKOpenChannel *this_ptr))[32]; + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +void OpenChannel_set_chain_hash(LDKOpenChannel *this_ptr, LDKThirtyTwoBytes val); + +/** + * A temporary channel ID, until the funding outpoint is announced + */ +const uint8_t (*OpenChannel_get_temporary_channel_id(const LDKOpenChannel *this_ptr))[32]; + +/** + * A temporary channel ID, until the funding outpoint is announced + */ +void OpenChannel_set_temporary_channel_id(LDKOpenChannel *this_ptr, LDKThirtyTwoBytes val); + +/** + * The channel value + */ +uint64_t OpenChannel_get_funding_satoshis(const LDKOpenChannel *this_ptr); + +/** + * The channel value + */ +void OpenChannel_set_funding_satoshis(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The amount to push to the counterparty as part of the open, in milli-satoshi + */ +uint64_t OpenChannel_get_push_msat(const LDKOpenChannel *this_ptr); + +/** + * The amount to push to the counterparty as part of the open, in milli-satoshi + */ +void OpenChannel_set_push_msat(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The threshold below which outputs on transactions broadcast by sender will be omitted + */ +uint64_t OpenChannel_get_dust_limit_satoshis(const LDKOpenChannel *this_ptr); + +/** + * The threshold below which outputs on transactions broadcast by sender will be omitted + */ +void OpenChannel_set_dust_limit_satoshis(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The maximum inbound HTLC value in flight towards sender, in milli-satoshi + */ +uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const LDKOpenChannel *this_ptr); + +/** + * The maximum inbound HTLC value in flight towards sender, in milli-satoshi + */ +void OpenChannel_set_max_htlc_value_in_flight_msat(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel + */ +uint64_t OpenChannel_get_channel_reserve_satoshis(const LDKOpenChannel *this_ptr); + +/** + * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel + */ +void OpenChannel_set_channel_reserve_satoshis(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +uint64_t OpenChannel_get_htlc_minimum_msat(const LDKOpenChannel *this_ptr); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +void OpenChannel_set_htlc_minimum_msat(LDKOpenChannel *this_ptr, uint64_t val); + +/** + * The feerate per 1000-weight of sender generated transactions, until updated by update_fee + */ +uint32_t OpenChannel_get_feerate_per_kw(const LDKOpenChannel *this_ptr); + +/** + * The feerate per 1000-weight of sender generated transactions, until updated by update_fee + */ +void OpenChannel_set_feerate_per_kw(LDKOpenChannel *this_ptr, uint32_t val); + +/** + * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction + */ +uint16_t OpenChannel_get_to_self_delay(const LDKOpenChannel *this_ptr); + +/** + * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction + */ +void OpenChannel_set_to_self_delay(LDKOpenChannel *this_ptr, uint16_t val); + +/** + * The maximum number of inbound HTLCs towards sender + */ +uint16_t OpenChannel_get_max_accepted_htlcs(const LDKOpenChannel *this_ptr); + +/** + * The maximum number of inbound HTLCs towards sender + */ +void OpenChannel_set_max_accepted_htlcs(LDKOpenChannel *this_ptr, uint16_t val); + +/** + * The sender's key controlling the funding transaction + */ +LDKPublicKey OpenChannel_get_funding_pubkey(const LDKOpenChannel *this_ptr); + +/** + * The sender's key controlling the funding transaction + */ +void OpenChannel_set_funding_pubkey(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive a revocation key for transactions broadcast by counterparty + */ +LDKPublicKey OpenChannel_get_revocation_basepoint(const LDKOpenChannel *this_ptr); + +/** + * Used to derive a revocation key for transactions broadcast by counterparty + */ +void OpenChannel_set_revocation_basepoint(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * A payment key to sender for transactions broadcast by counterparty + */ +LDKPublicKey OpenChannel_get_payment_point(const LDKOpenChannel *this_ptr); + +/** + * A payment key to sender for transactions broadcast by counterparty + */ +void OpenChannel_set_payment_point(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive a payment key to sender for transactions broadcast by sender + */ +LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const LDKOpenChannel *this_ptr); + +/** + * Used to derive a payment key to sender for transactions broadcast by sender + */ +void OpenChannel_set_delayed_payment_basepoint(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive an HTLC payment key to sender + */ +LDKPublicKey OpenChannel_get_htlc_basepoint(const LDKOpenChannel *this_ptr); + +/** + * Used to derive an HTLC payment key to sender + */ +void OpenChannel_set_htlc_basepoint(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * The first to-be-broadcast-by-sender transaction's per commitment point + */ +LDKPublicKey OpenChannel_get_first_per_commitment_point(const LDKOpenChannel *this_ptr); + +/** + * The first to-be-broadcast-by-sender transaction's per commitment point + */ +void OpenChannel_set_first_per_commitment_point(LDKOpenChannel *this_ptr, LDKPublicKey val); + +/** + * Channel flags + */ +uint8_t OpenChannel_get_channel_flags(const LDKOpenChannel *this_ptr); + +/** + * Channel flags + */ +void OpenChannel_set_channel_flags(LDKOpenChannel *this_ptr, uint8_t val); + +void AcceptChannel_free(LDKAcceptChannel this_ptr); + +/** + * A temporary channel ID, until the funding outpoint is announced + */ +const uint8_t (*AcceptChannel_get_temporary_channel_id(const LDKAcceptChannel *this_ptr))[32]; + +/** + * A temporary channel ID, until the funding outpoint is announced + */ +void AcceptChannel_set_temporary_channel_id(LDKAcceptChannel *this_ptr, LDKThirtyTwoBytes val); + +/** + * The threshold below which outputs on transactions broadcast by sender will be omitted + */ +uint64_t AcceptChannel_get_dust_limit_satoshis(const LDKAcceptChannel *this_ptr); + +/** + * The threshold below which outputs on transactions broadcast by sender will be omitted + */ +void AcceptChannel_set_dust_limit_satoshis(LDKAcceptChannel *this_ptr, uint64_t val); + +/** + * The maximum inbound HTLC value in flight towards sender, in milli-satoshi + */ +uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const LDKAcceptChannel *this_ptr); + +/** + * The maximum inbound HTLC value in flight towards sender, in milli-satoshi + */ +void AcceptChannel_set_max_htlc_value_in_flight_msat(LDKAcceptChannel *this_ptr, uint64_t val); + +/** + * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel + */ +uint64_t AcceptChannel_get_channel_reserve_satoshis(const LDKAcceptChannel *this_ptr); + +/** + * The minimum value unencumbered by HTLCs for the counterparty to keep in the channel + */ +void AcceptChannel_set_channel_reserve_satoshis(LDKAcceptChannel *this_ptr, uint64_t val); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +uint64_t AcceptChannel_get_htlc_minimum_msat(const LDKAcceptChannel *this_ptr); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +void AcceptChannel_set_htlc_minimum_msat(LDKAcceptChannel *this_ptr, uint64_t val); + +/** + * Minimum depth of the funding transaction before the channel is considered open + */ +uint32_t AcceptChannel_get_minimum_depth(const LDKAcceptChannel *this_ptr); + +/** + * Minimum depth of the funding transaction before the channel is considered open + */ +void AcceptChannel_set_minimum_depth(LDKAcceptChannel *this_ptr, uint32_t val); + +/** + * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction + */ +uint16_t AcceptChannel_get_to_self_delay(const LDKAcceptChannel *this_ptr); + +/** + * The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction + */ +void AcceptChannel_set_to_self_delay(LDKAcceptChannel *this_ptr, uint16_t val); + +/** + * The maximum number of inbound HTLCs towards sender + */ +uint16_t AcceptChannel_get_max_accepted_htlcs(const LDKAcceptChannel *this_ptr); + +/** + * The maximum number of inbound HTLCs towards sender + */ +void AcceptChannel_set_max_accepted_htlcs(LDKAcceptChannel *this_ptr, uint16_t val); + +/** + * The sender's key controlling the funding transaction + */ +LDKPublicKey AcceptChannel_get_funding_pubkey(const LDKAcceptChannel *this_ptr); + +/** + * The sender's key controlling the funding transaction + */ +void AcceptChannel_set_funding_pubkey(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive a revocation key for transactions broadcast by counterparty + */ +LDKPublicKey AcceptChannel_get_revocation_basepoint(const LDKAcceptChannel *this_ptr); + +/** + * Used to derive a revocation key for transactions broadcast by counterparty + */ +void AcceptChannel_set_revocation_basepoint(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +/** + * A payment key to sender for transactions broadcast by counterparty + */ +LDKPublicKey AcceptChannel_get_payment_point(const LDKAcceptChannel *this_ptr); + +/** + * A payment key to sender for transactions broadcast by counterparty + */ +void AcceptChannel_set_payment_point(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive a payment key to sender for transactions broadcast by sender + */ +LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const LDKAcceptChannel *this_ptr); + +/** + * Used to derive a payment key to sender for transactions broadcast by sender + */ +void AcceptChannel_set_delayed_payment_basepoint(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +/** + * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty + */ +LDKPublicKey AcceptChannel_get_htlc_basepoint(const LDKAcceptChannel *this_ptr); + +/** + * Used to derive an HTLC payment key to sender for transactions broadcast by counterparty + */ +void AcceptChannel_set_htlc_basepoint(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +/** + * The first to-be-broadcast-by-sender transaction's per commitment point + */ +LDKPublicKey AcceptChannel_get_first_per_commitment_point(const LDKAcceptChannel *this_ptr); + +/** + * The first to-be-broadcast-by-sender transaction's per commitment point + */ +void AcceptChannel_set_first_per_commitment_point(LDKAcceptChannel *this_ptr, LDKPublicKey val); + +void FundingCreated_free(LDKFundingCreated this_ptr); + +/** + * A temporary channel ID, until the funding is established + */ +const uint8_t (*FundingCreated_get_temporary_channel_id(const LDKFundingCreated *this_ptr))[32]; + +/** + * A temporary channel ID, until the funding is established + */ +void FundingCreated_set_temporary_channel_id(LDKFundingCreated *this_ptr, LDKThirtyTwoBytes val); + +/** + * The funding transaction ID + */ +const uint8_t (*FundingCreated_get_funding_txid(const LDKFundingCreated *this_ptr))[32]; + +/** + * The funding transaction ID + */ +void FundingCreated_set_funding_txid(LDKFundingCreated *this_ptr, LDKThirtyTwoBytes val); + +/** + * The specific output index funding this channel + */ +uint16_t FundingCreated_get_funding_output_index(const LDKFundingCreated *this_ptr); + +/** + * The specific output index funding this channel + */ +void FundingCreated_set_funding_output_index(LDKFundingCreated *this_ptr, uint16_t val); + +/** + * The signature of the channel initiator (funder) on the funding transaction + */ +LDKSignature FundingCreated_get_signature(const LDKFundingCreated *this_ptr); + +/** + * The signature of the channel initiator (funder) on the funding transaction + */ +void FundingCreated_set_signature(LDKFundingCreated *this_ptr, LDKSignature val); + +MUST_USE_RES LDKFundingCreated FundingCreated_new(LDKThirtyTwoBytes temporary_channel_id_arg, LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, LDKSignature signature_arg); + +void FundingSigned_free(LDKFundingSigned this_ptr); + +/** + * The channel ID + */ +const uint8_t (*FundingSigned_get_channel_id(const LDKFundingSigned *this_ptr))[32]; + +/** + * The channel ID + */ +void FundingSigned_set_channel_id(LDKFundingSigned *this_ptr, LDKThirtyTwoBytes val); + +/** + * The signature of the channel acceptor (fundee) on the funding transaction + */ +LDKSignature FundingSigned_get_signature(const LDKFundingSigned *this_ptr); + +/** + * The signature of the channel acceptor (fundee) on the funding transaction + */ +void FundingSigned_set_signature(LDKFundingSigned *this_ptr, LDKSignature val); + +MUST_USE_RES LDKFundingSigned FundingSigned_new(LDKThirtyTwoBytes channel_id_arg, LDKSignature signature_arg); + +void FundingLocked_free(LDKFundingLocked this_ptr); + +/** + * The channel ID + */ +const uint8_t (*FundingLocked_get_channel_id(const LDKFundingLocked *this_ptr))[32]; + +/** + * The channel ID + */ +void FundingLocked_set_channel_id(LDKFundingLocked *this_ptr, LDKThirtyTwoBytes val); + +/** + * The per-commitment point of the second commitment transaction + */ +LDKPublicKey FundingLocked_get_next_per_commitment_point(const LDKFundingLocked *this_ptr); + +/** + * The per-commitment point of the second commitment transaction + */ +void FundingLocked_set_next_per_commitment_point(LDKFundingLocked *this_ptr, LDKPublicKey val); + +MUST_USE_RES LDKFundingLocked FundingLocked_new(LDKThirtyTwoBytes channel_id_arg, LDKPublicKey next_per_commitment_point_arg); + +void Shutdown_free(LDKShutdown this_ptr); + +/** + * The channel ID + */ +const uint8_t (*Shutdown_get_channel_id(const LDKShutdown *this_ptr))[32]; + +/** + * The channel ID + */ +void Shutdown_set_channel_id(LDKShutdown *this_ptr, LDKThirtyTwoBytes val); + +/** + * The destination of this peer's funds on closing. + * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh. + */ +LDKu8slice Shutdown_get_scriptpubkey(const LDKShutdown *this_ptr); + +/** + * The destination of this peer's funds on closing. + * Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh. + */ +void Shutdown_set_scriptpubkey(LDKShutdown *this_ptr, LDKCVec_u8Z val); + +MUST_USE_RES LDKShutdown Shutdown_new(LDKThirtyTwoBytes channel_id_arg, LDKCVec_u8Z scriptpubkey_arg); + +void ClosingSigned_free(LDKClosingSigned this_ptr); + +/** + * The channel ID + */ +const uint8_t (*ClosingSigned_get_channel_id(const LDKClosingSigned *this_ptr))[32]; + +/** + * The channel ID + */ +void ClosingSigned_set_channel_id(LDKClosingSigned *this_ptr, LDKThirtyTwoBytes val); + +/** + * The proposed total fee for the closing transaction + */ +uint64_t ClosingSigned_get_fee_satoshis(const LDKClosingSigned *this_ptr); + +/** + * The proposed total fee for the closing transaction + */ +void ClosingSigned_set_fee_satoshis(LDKClosingSigned *this_ptr, uint64_t val); + +/** + * A signature on the closing transaction + */ +LDKSignature ClosingSigned_get_signature(const LDKClosingSigned *this_ptr); + +/** + * A signature on the closing transaction + */ +void ClosingSigned_set_signature(LDKClosingSigned *this_ptr, LDKSignature val); + +MUST_USE_RES LDKClosingSigned ClosingSigned_new(LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, LDKSignature signature_arg); + +void UpdateAddHTLC_free(LDKUpdateAddHTLC this_ptr); + +/** + * The channel ID + */ +const uint8_t (*UpdateAddHTLC_get_channel_id(const LDKUpdateAddHTLC *this_ptr))[32]; + +/** + * The channel ID + */ +void UpdateAddHTLC_set_channel_id(LDKUpdateAddHTLC *this_ptr, LDKThirtyTwoBytes val); + +/** + * The HTLC ID + */ +uint64_t UpdateAddHTLC_get_htlc_id(const LDKUpdateAddHTLC *this_ptr); + +/** + * The HTLC ID + */ +void UpdateAddHTLC_set_htlc_id(LDKUpdateAddHTLC *this_ptr, uint64_t val); + +/** + * The HTLC value in milli-satoshi + */ +uint64_t UpdateAddHTLC_get_amount_msat(const LDKUpdateAddHTLC *this_ptr); + +/** + * The HTLC value in milli-satoshi + */ +void UpdateAddHTLC_set_amount_msat(LDKUpdateAddHTLC *this_ptr, uint64_t val); + +/** + * The payment hash, the pre-image of which controls HTLC redemption + */ +const uint8_t (*UpdateAddHTLC_get_payment_hash(const LDKUpdateAddHTLC *this_ptr))[32]; + +/** + * The payment hash, the pre-image of which controls HTLC redemption + */ +void UpdateAddHTLC_set_payment_hash(LDKUpdateAddHTLC *this_ptr, LDKThirtyTwoBytes val); + +/** + * The expiry height of the HTLC + */ +uint32_t UpdateAddHTLC_get_cltv_expiry(const LDKUpdateAddHTLC *this_ptr); + +/** + * The expiry height of the HTLC + */ +void UpdateAddHTLC_set_cltv_expiry(LDKUpdateAddHTLC *this_ptr, uint32_t val); + +void UpdateFulfillHTLC_free(LDKUpdateFulfillHTLC this_ptr); + +/** + * The channel ID + */ +const uint8_t (*UpdateFulfillHTLC_get_channel_id(const LDKUpdateFulfillHTLC *this_ptr))[32]; + +/** + * The channel ID + */ +void UpdateFulfillHTLC_set_channel_id(LDKUpdateFulfillHTLC *this_ptr, LDKThirtyTwoBytes val); + +/** + * The HTLC ID + */ +uint64_t UpdateFulfillHTLC_get_htlc_id(const LDKUpdateFulfillHTLC *this_ptr); + +/** + * The HTLC ID + */ +void UpdateFulfillHTLC_set_htlc_id(LDKUpdateFulfillHTLC *this_ptr, uint64_t val); + +/** + * The pre-image of the payment hash, allowing HTLC redemption + */ +const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const LDKUpdateFulfillHTLC *this_ptr))[32]; + +/** + * The pre-image of the payment hash, allowing HTLC redemption + */ +void UpdateFulfillHTLC_set_payment_preimage(LDKUpdateFulfillHTLC *this_ptr, LDKThirtyTwoBytes val); + +MUST_USE_RES LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, LDKThirtyTwoBytes payment_preimage_arg); + +void UpdateFailHTLC_free(LDKUpdateFailHTLC this_ptr); + +/** + * The channel ID + */ +const uint8_t (*UpdateFailHTLC_get_channel_id(const LDKUpdateFailHTLC *this_ptr))[32]; + +/** + * The channel ID + */ +void UpdateFailHTLC_set_channel_id(LDKUpdateFailHTLC *this_ptr, LDKThirtyTwoBytes val); + +/** + * The HTLC ID + */ +uint64_t UpdateFailHTLC_get_htlc_id(const LDKUpdateFailHTLC *this_ptr); + +/** + * The HTLC ID + */ +void UpdateFailHTLC_set_htlc_id(LDKUpdateFailHTLC *this_ptr, uint64_t val); + +void UpdateFailMalformedHTLC_free(LDKUpdateFailMalformedHTLC this_ptr); + +/** + * The channel ID + */ +const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const LDKUpdateFailMalformedHTLC *this_ptr))[32]; + +/** + * The channel ID + */ +void UpdateFailMalformedHTLC_set_channel_id(LDKUpdateFailMalformedHTLC *this_ptr, LDKThirtyTwoBytes val); + +/** + * The HTLC ID + */ +uint64_t UpdateFailMalformedHTLC_get_htlc_id(const LDKUpdateFailMalformedHTLC *this_ptr); + +/** + * The HTLC ID + */ +void UpdateFailMalformedHTLC_set_htlc_id(LDKUpdateFailMalformedHTLC *this_ptr, uint64_t val); + +/** + * The failure code + */ +uint16_t UpdateFailMalformedHTLC_get_failure_code(const LDKUpdateFailMalformedHTLC *this_ptr); + +/** + * The failure code + */ +void UpdateFailMalformedHTLC_set_failure_code(LDKUpdateFailMalformedHTLC *this_ptr, uint16_t val); + +void CommitmentSigned_free(LDKCommitmentSigned this_ptr); + +/** + * The channel ID + */ +const uint8_t (*CommitmentSigned_get_channel_id(const LDKCommitmentSigned *this_ptr))[32]; + +/** + * The channel ID + */ +void CommitmentSigned_set_channel_id(LDKCommitmentSigned *this_ptr, LDKThirtyTwoBytes val); + +/** + * A signature on the commitment transaction + */ +LDKSignature CommitmentSigned_get_signature(const LDKCommitmentSigned *this_ptr); + +/** + * A signature on the commitment transaction + */ +void CommitmentSigned_set_signature(LDKCommitmentSigned *this_ptr, LDKSignature val); + +/** + * Signatures on the HTLC transactions + */ +void CommitmentSigned_set_htlc_signatures(LDKCommitmentSigned *this_ptr, LDKCVec_SignatureZ val); + +MUST_USE_RES LDKCommitmentSigned CommitmentSigned_new(LDKThirtyTwoBytes channel_id_arg, LDKSignature signature_arg, LDKCVec_SignatureZ htlc_signatures_arg); + +void RevokeAndACK_free(LDKRevokeAndACK this_ptr); + +/** + * The channel ID + */ +const uint8_t (*RevokeAndACK_get_channel_id(const LDKRevokeAndACK *this_ptr))[32]; + +/** + * The channel ID + */ +void RevokeAndACK_set_channel_id(LDKRevokeAndACK *this_ptr, LDKThirtyTwoBytes val); + +/** + * The secret corresponding to the per-commitment point + */ +const uint8_t (*RevokeAndACK_get_per_commitment_secret(const LDKRevokeAndACK *this_ptr))[32]; + +/** + * The secret corresponding to the per-commitment point + */ +void RevokeAndACK_set_per_commitment_secret(LDKRevokeAndACK *this_ptr, LDKThirtyTwoBytes val); + +/** + * The next sender-broadcast commitment transaction's per-commitment point + */ +LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const LDKRevokeAndACK *this_ptr); + +/** + * The next sender-broadcast commitment transaction's per-commitment point + */ +void RevokeAndACK_set_next_per_commitment_point(LDKRevokeAndACK *this_ptr, LDKPublicKey val); + +MUST_USE_RES LDKRevokeAndACK RevokeAndACK_new(LDKThirtyTwoBytes channel_id_arg, LDKThirtyTwoBytes per_commitment_secret_arg, LDKPublicKey next_per_commitment_point_arg); + +void UpdateFee_free(LDKUpdateFee this_ptr); + +/** + * The channel ID + */ +const uint8_t (*UpdateFee_get_channel_id(const LDKUpdateFee *this_ptr))[32]; + +/** + * The channel ID + */ +void UpdateFee_set_channel_id(LDKUpdateFee *this_ptr, LDKThirtyTwoBytes val); + +/** + * Fee rate per 1000-weight of the transaction + */ +uint32_t UpdateFee_get_feerate_per_kw(const LDKUpdateFee *this_ptr); + +/** + * Fee rate per 1000-weight of the transaction + */ +void UpdateFee_set_feerate_per_kw(LDKUpdateFee *this_ptr, uint32_t val); + +MUST_USE_RES LDKUpdateFee UpdateFee_new(LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg); + +void DataLossProtect_free(LDKDataLossProtect this_ptr); + +/** + * Proof that the sender knows the per-commitment secret of a specific commitment transaction + * belonging to the recipient + */ +const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const LDKDataLossProtect *this_ptr))[32]; + +/** + * Proof that the sender knows the per-commitment secret of a specific commitment transaction + * belonging to the recipient + */ +void DataLossProtect_set_your_last_per_commitment_secret(LDKDataLossProtect *this_ptr, LDKThirtyTwoBytes val); + +/** + * The sender's per-commitment point for their current commitment transaction + */ +LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const LDKDataLossProtect *this_ptr); + +/** + * The sender's per-commitment point for their current commitment transaction + */ +void DataLossProtect_set_my_current_per_commitment_point(LDKDataLossProtect *this_ptr, LDKPublicKey val); + +MUST_USE_RES LDKDataLossProtect DataLossProtect_new(LDKThirtyTwoBytes your_last_per_commitment_secret_arg, LDKPublicKey my_current_per_commitment_point_arg); + +void ChannelReestablish_free(LDKChannelReestablish this_ptr); + +/** + * The channel ID + */ +const uint8_t (*ChannelReestablish_get_channel_id(const LDKChannelReestablish *this_ptr))[32]; + +/** + * The channel ID + */ +void ChannelReestablish_set_channel_id(LDKChannelReestablish *this_ptr, LDKThirtyTwoBytes val); + +/** + * The next commitment number for the sender + */ +uint64_t ChannelReestablish_get_next_local_commitment_number(const LDKChannelReestablish *this_ptr); + +/** + * The next commitment number for the sender + */ +void ChannelReestablish_set_next_local_commitment_number(LDKChannelReestablish *this_ptr, uint64_t val); + +/** + * The next commitment number for the recipient + */ +uint64_t ChannelReestablish_get_next_remote_commitment_number(const LDKChannelReestablish *this_ptr); + +/** + * The next commitment number for the recipient + */ +void ChannelReestablish_set_next_remote_commitment_number(LDKChannelReestablish *this_ptr, uint64_t val); + +void AnnouncementSignatures_free(LDKAnnouncementSignatures this_ptr); + +/** + * The channel ID + */ +const uint8_t (*AnnouncementSignatures_get_channel_id(const LDKAnnouncementSignatures *this_ptr))[32]; + +/** + * The channel ID + */ +void AnnouncementSignatures_set_channel_id(LDKAnnouncementSignatures *this_ptr, LDKThirtyTwoBytes val); + +/** + * The short channel ID + */ +uint64_t AnnouncementSignatures_get_short_channel_id(const LDKAnnouncementSignatures *this_ptr); + +/** + * The short channel ID + */ +void AnnouncementSignatures_set_short_channel_id(LDKAnnouncementSignatures *this_ptr, uint64_t val); + +/** + * A signature by the node key + */ +LDKSignature AnnouncementSignatures_get_node_signature(const LDKAnnouncementSignatures *this_ptr); + +/** + * A signature by the node key + */ +void AnnouncementSignatures_set_node_signature(LDKAnnouncementSignatures *this_ptr, LDKSignature val); + +/** + * A signature by the funding key + */ +LDKSignature AnnouncementSignatures_get_bitcoin_signature(const LDKAnnouncementSignatures *this_ptr); + +/** + * A signature by the funding key + */ +void AnnouncementSignatures_set_bitcoin_signature(LDKAnnouncementSignatures *this_ptr, LDKSignature val); + +MUST_USE_RES LDKAnnouncementSignatures AnnouncementSignatures_new(LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, LDKSignature node_signature_arg, LDKSignature bitcoin_signature_arg); + +void NetAddress_free(LDKNetAddress this_ptr); + +void UnsignedNodeAnnouncement_free(LDKUnsignedNodeAnnouncement this_ptr); + +/** + * A strictly monotonic announcement counter, with gaps allowed + */ +uint32_t UnsignedNodeAnnouncement_get_timestamp(const LDKUnsignedNodeAnnouncement *this_ptr); + +/** + * A strictly monotonic announcement counter, with gaps allowed + */ +void UnsignedNodeAnnouncement_set_timestamp(LDKUnsignedNodeAnnouncement *this_ptr, uint32_t val); + +/** + * The node_id this announcement originated from (don't rebroadcast the node_announcement back + * to this node). + */ +LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const LDKUnsignedNodeAnnouncement *this_ptr); + +/** + * The node_id this announcement originated from (don't rebroadcast the node_announcement back + * to this node). + */ +void UnsignedNodeAnnouncement_set_node_id(LDKUnsignedNodeAnnouncement *this_ptr, LDKPublicKey val); + +/** + * An RGB color for UI purposes + */ +const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const LDKUnsignedNodeAnnouncement *this_ptr))[3]; + +/** + * An RGB color for UI purposes + */ +void UnsignedNodeAnnouncement_set_rgb(LDKUnsignedNodeAnnouncement *this_ptr, LDKThreeBytes val); + +/** + * An alias, for UI purposes. This should be sanitized before use. There is no guarantee + * of uniqueness. + */ +const uint8_t (*UnsignedNodeAnnouncement_get_alias(const LDKUnsignedNodeAnnouncement *this_ptr))[32]; + +/** + * An alias, for UI purposes. This should be sanitized before use. There is no guarantee + * of uniqueness. + */ +void UnsignedNodeAnnouncement_set_alias(LDKUnsignedNodeAnnouncement *this_ptr, LDKThirtyTwoBytes val); + +/** + * List of addresses on which this node is reachable + */ +void UnsignedNodeAnnouncement_set_addresses(LDKUnsignedNodeAnnouncement *this_ptr, LDKCVec_NetAddressZ val); + +void NodeAnnouncement_free(LDKNodeAnnouncement this_ptr); + +/** + * The signature by the node key + */ +LDKSignature NodeAnnouncement_get_signature(const LDKNodeAnnouncement *this_ptr); + +/** + * The signature by the node key + */ +void NodeAnnouncement_set_signature(LDKNodeAnnouncement *this_ptr, LDKSignature val); + +/** + * The actual content of the announcement + */ +LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const LDKNodeAnnouncement *this_ptr); + +/** + * The actual content of the announcement + */ +void NodeAnnouncement_set_contents(LDKNodeAnnouncement *this_ptr, LDKUnsignedNodeAnnouncement val); + +MUST_USE_RES LDKNodeAnnouncement NodeAnnouncement_new(LDKSignature signature_arg, LDKUnsignedNodeAnnouncement contents_arg); + +void UnsignedChannelAnnouncement_free(LDKUnsignedChannelAnnouncement this_ptr); + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const LDKUnsignedChannelAnnouncement *this_ptr))[32]; + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +void UnsignedChannelAnnouncement_set_chain_hash(LDKUnsignedChannelAnnouncement *this_ptr, LDKThirtyTwoBytes val); + +/** + * The short channel ID + */ +uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const LDKUnsignedChannelAnnouncement *this_ptr); + +/** + * The short channel ID + */ +void UnsignedChannelAnnouncement_set_short_channel_id(LDKUnsignedChannelAnnouncement *this_ptr, uint64_t val); + +/** + * One of the two node_ids which are endpoints of this channel + */ +LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const LDKUnsignedChannelAnnouncement *this_ptr); + +/** + * One of the two node_ids which are endpoints of this channel + */ +void UnsignedChannelAnnouncement_set_node_id_1(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val); + +/** + * The other of the two node_ids which are endpoints of this channel + */ +LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const LDKUnsignedChannelAnnouncement *this_ptr); + +/** + * The other of the two node_ids which are endpoints of this channel + */ +void UnsignedChannelAnnouncement_set_node_id_2(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val); + +/** + * The funding key for the first node + */ +LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const LDKUnsignedChannelAnnouncement *this_ptr); + +/** + * The funding key for the first node + */ +void UnsignedChannelAnnouncement_set_bitcoin_key_1(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val); + +/** + * The funding key for the second node + */ +LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const LDKUnsignedChannelAnnouncement *this_ptr); + +/** + * The funding key for the second node + */ +void UnsignedChannelAnnouncement_set_bitcoin_key_2(LDKUnsignedChannelAnnouncement *this_ptr, LDKPublicKey val); + +void ChannelAnnouncement_free(LDKChannelAnnouncement this_ptr); + +/** + * Authentication of the announcement by the first public node + */ +LDKSignature ChannelAnnouncement_get_node_signature_1(const LDKChannelAnnouncement *this_ptr); + +/** + * Authentication of the announcement by the first public node + */ +void ChannelAnnouncement_set_node_signature_1(LDKChannelAnnouncement *this_ptr, LDKSignature val); + +/** + * Authentication of the announcement by the second public node + */ +LDKSignature ChannelAnnouncement_get_node_signature_2(const LDKChannelAnnouncement *this_ptr); + +/** + * Authentication of the announcement by the second public node + */ +void ChannelAnnouncement_set_node_signature_2(LDKChannelAnnouncement *this_ptr, LDKSignature val); + +/** + * Proof of funding UTXO ownership by the first public node + */ +LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const LDKChannelAnnouncement *this_ptr); + +/** + * Proof of funding UTXO ownership by the first public node + */ +void ChannelAnnouncement_set_bitcoin_signature_1(LDKChannelAnnouncement *this_ptr, LDKSignature val); + +/** + * Proof of funding UTXO ownership by the second public node + */ +LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const LDKChannelAnnouncement *this_ptr); + +/** + * Proof of funding UTXO ownership by the second public node + */ +void ChannelAnnouncement_set_bitcoin_signature_2(LDKChannelAnnouncement *this_ptr, LDKSignature val); + +/** + * The actual announcement + */ +LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const LDKChannelAnnouncement *this_ptr); + +/** + * The actual announcement + */ +void ChannelAnnouncement_set_contents(LDKChannelAnnouncement *this_ptr, LDKUnsignedChannelAnnouncement val); + +MUST_USE_RES LDKChannelAnnouncement ChannelAnnouncement_new(LDKSignature node_signature_1_arg, LDKSignature node_signature_2_arg, LDKSignature bitcoin_signature_1_arg, LDKSignature bitcoin_signature_2_arg, LDKUnsignedChannelAnnouncement contents_arg); + +void UnsignedChannelUpdate_free(LDKUnsignedChannelUpdate this_ptr); + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const LDKUnsignedChannelUpdate *this_ptr))[32]; + +/** + * The genesis hash of the blockchain where the channel is to be opened + */ +void UnsignedChannelUpdate_set_chain_hash(LDKUnsignedChannelUpdate *this_ptr, LDKThirtyTwoBytes val); + +/** + * The short channel ID + */ +uint64_t UnsignedChannelUpdate_get_short_channel_id(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * The short channel ID + */ +void UnsignedChannelUpdate_set_short_channel_id(LDKUnsignedChannelUpdate *this_ptr, uint64_t val); + +/** + * A strictly monotonic announcement counter, with gaps allowed, specific to this channel + */ +uint32_t UnsignedChannelUpdate_get_timestamp(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * A strictly monotonic announcement counter, with gaps allowed, specific to this channel + */ +void UnsignedChannelUpdate_set_timestamp(LDKUnsignedChannelUpdate *this_ptr, uint32_t val); + +/** + * Channel flags + */ +uint8_t UnsignedChannelUpdate_get_flags(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * Channel flags + */ +void UnsignedChannelUpdate_set_flags(LDKUnsignedChannelUpdate *this_ptr, uint8_t val); + +/** + * The number of blocks to subtract from incoming HTLC cltv_expiry values + */ +uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * The number of blocks to subtract from incoming HTLC cltv_expiry values + */ +void UnsignedChannelUpdate_set_cltv_expiry_delta(LDKUnsignedChannelUpdate *this_ptr, uint16_t val); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * The minimum HTLC size incoming to sender, in milli-satoshi + */ +void UnsignedChannelUpdate_set_htlc_minimum_msat(LDKUnsignedChannelUpdate *this_ptr, uint64_t val); + +/** + * The base HTLC fee charged by sender, in milli-satoshi + */ +uint32_t UnsignedChannelUpdate_get_fee_base_msat(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * The base HTLC fee charged by sender, in milli-satoshi + */ +void UnsignedChannelUpdate_set_fee_base_msat(LDKUnsignedChannelUpdate *this_ptr, uint32_t val); + +/** + * The amount to fee multiplier, in micro-satoshi + */ +uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const LDKUnsignedChannelUpdate *this_ptr); + +/** + * The amount to fee multiplier, in micro-satoshi + */ +void UnsignedChannelUpdate_set_fee_proportional_millionths(LDKUnsignedChannelUpdate *this_ptr, uint32_t val); + +void ChannelUpdate_free(LDKChannelUpdate this_ptr); + +/** + * A signature of the channel update + */ +LDKSignature ChannelUpdate_get_signature(const LDKChannelUpdate *this_ptr); + +/** + * A signature of the channel update + */ +void ChannelUpdate_set_signature(LDKChannelUpdate *this_ptr, LDKSignature val); + +/** + * The actual channel update + */ +LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const LDKChannelUpdate *this_ptr); + +/** + * The actual channel update + */ +void ChannelUpdate_set_contents(LDKChannelUpdate *this_ptr, LDKUnsignedChannelUpdate val); + +MUST_USE_RES LDKChannelUpdate ChannelUpdate_new(LDKSignature signature_arg, LDKUnsignedChannelUpdate contents_arg); + +void ErrorAction_free(LDKErrorAction this_ptr); + +void LightningError_free(LDKLightningError this_ptr); + +/** + * A human-readable message describing the error + */ +LDKStr LightningError_get_err(const LDKLightningError *this_ptr); + +/** + * A human-readable message describing the error + */ +void LightningError_set_err(LDKLightningError *this_ptr, LDKCVec_u8Z val); + +/** + * The action which should be taken against the offending peer. + */ +LDKErrorAction LightningError_get_action(const LDKLightningError *this_ptr); + +/** + * The action which should be taken against the offending peer. + */ +void LightningError_set_action(LDKLightningError *this_ptr, LDKErrorAction val); + +MUST_USE_RES LDKLightningError LightningError_new(LDKCVec_u8Z err_arg, LDKErrorAction action_arg); + +void CommitmentUpdate_free(LDKCommitmentUpdate this_ptr); + +/** + * update_add_htlc messages which should be sent + */ +void CommitmentUpdate_set_update_add_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateAddHTLCZ val); + +/** + * update_fulfill_htlc messages which should be sent + */ +void CommitmentUpdate_set_update_fulfill_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFulfillHTLCZ val); + +/** + * update_fail_htlc messages which should be sent + */ +void CommitmentUpdate_set_update_fail_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFailHTLCZ val); + +/** + * update_fail_malformed_htlc messages which should be sent + */ +void CommitmentUpdate_set_update_fail_malformed_htlcs(LDKCommitmentUpdate *this_ptr, LDKCVec_UpdateFailMalformedHTLCZ val); + +/** + * An update_fee message which should be sent + */ +LDKUpdateFee CommitmentUpdate_get_update_fee(const LDKCommitmentUpdate *this_ptr); + +/** + * An update_fee message which should be sent + */ +void CommitmentUpdate_set_update_fee(LDKCommitmentUpdate *this_ptr, LDKUpdateFee val); + +/** + * Finally, the commitment_signed message which should be sent + */ +LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const LDKCommitmentUpdate *this_ptr); + +/** + * Finally, the commitment_signed message which should be sent + */ +void CommitmentUpdate_set_commitment_signed(LDKCommitmentUpdate *this_ptr, LDKCommitmentSigned val); + +MUST_USE_RES LDKCommitmentUpdate CommitmentUpdate_new(LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg, LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg, LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg, LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg, LDKUpdateFee update_fee_arg, LDKCommitmentSigned commitment_signed_arg); + +void HTLCFailChannelUpdate_free(LDKHTLCFailChannelUpdate this_ptr); + +/** + * Calls the free function if one is set + */ +void ChannelMessageHandler_free(LDKChannelMessageHandler this_ptr); + +/** + * Calls the free function if one is set + */ +void RoutingMessageHandler_free(LDKRoutingMessageHandler this_ptr); + +LDKCVec_u8Z AcceptChannel_write(const LDKAcceptChannel *obj); + +LDKAcceptChannel AcceptChannel_read(LDKu8slice ser); + +LDKCVec_u8Z AnnouncementSignatures_write(const LDKAnnouncementSignatures *obj); + +LDKAnnouncementSignatures AnnouncementSignatures_read(LDKu8slice ser); + +LDKCVec_u8Z ChannelReestablish_write(const LDKChannelReestablish *obj); + +LDKChannelReestablish ChannelReestablish_read(LDKu8slice ser); + +LDKCVec_u8Z ClosingSigned_write(const LDKClosingSigned *obj); + +LDKClosingSigned ClosingSigned_read(LDKu8slice ser); + +LDKCVec_u8Z CommitmentSigned_write(const LDKCommitmentSigned *obj); + +LDKCommitmentSigned CommitmentSigned_read(LDKu8slice ser); + +LDKCVec_u8Z FundingCreated_write(const LDKFundingCreated *obj); + +LDKFundingCreated FundingCreated_read(LDKu8slice ser); + +LDKCVec_u8Z FundingSigned_write(const LDKFundingSigned *obj); + +LDKFundingSigned FundingSigned_read(LDKu8slice ser); + +LDKCVec_u8Z FundingLocked_write(const LDKFundingLocked *obj); + +LDKFundingLocked FundingLocked_read(LDKu8slice ser); + +LDKCVec_u8Z Init_write(const LDKInit *obj); + +LDKInit Init_read(LDKu8slice ser); + +LDKCVec_u8Z OpenChannel_write(const LDKOpenChannel *obj); + +LDKOpenChannel OpenChannel_read(LDKu8slice ser); + +LDKCVec_u8Z RevokeAndACK_write(const LDKRevokeAndACK *obj); + +LDKRevokeAndACK RevokeAndACK_read(LDKu8slice ser); + +LDKCVec_u8Z Shutdown_write(const LDKShutdown *obj); + +LDKShutdown Shutdown_read(LDKu8slice ser); + +LDKCVec_u8Z UpdateFailHTLC_write(const LDKUpdateFailHTLC *obj); + +LDKUpdateFailHTLC UpdateFailHTLC_read(LDKu8slice ser); + +LDKCVec_u8Z UpdateFailMalformedHTLC_write(const LDKUpdateFailMalformedHTLC *obj); + +LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_read(LDKu8slice ser); + +LDKCVec_u8Z UpdateFee_write(const LDKUpdateFee *obj); + +LDKUpdateFee UpdateFee_read(LDKu8slice ser); + +LDKCVec_u8Z UpdateFulfillHTLC_write(const LDKUpdateFulfillHTLC *obj); + +LDKUpdateFulfillHTLC UpdateFulfillHTLC_read(LDKu8slice ser); + +LDKCVec_u8Z UpdateAddHTLC_write(const LDKUpdateAddHTLC *obj); + +LDKUpdateAddHTLC UpdateAddHTLC_read(LDKu8slice ser); + +LDKCVec_u8Z Ping_write(const LDKPing *obj); + +LDKPing Ping_read(LDKu8slice ser); + +LDKCVec_u8Z Pong_write(const LDKPong *obj); + +LDKPong Pong_read(LDKu8slice ser); + +LDKCVec_u8Z UnsignedChannelAnnouncement_write(const LDKUnsignedChannelAnnouncement *obj); + +LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_read(LDKu8slice ser); + +LDKCVec_u8Z ChannelAnnouncement_write(const LDKChannelAnnouncement *obj); + +LDKChannelAnnouncement ChannelAnnouncement_read(LDKu8slice ser); + +LDKCVec_u8Z UnsignedChannelUpdate_write(const LDKUnsignedChannelUpdate *obj); + +LDKUnsignedChannelUpdate UnsignedChannelUpdate_read(LDKu8slice ser); + +LDKCVec_u8Z ChannelUpdate_write(const LDKChannelUpdate *obj); + +LDKChannelUpdate ChannelUpdate_read(LDKu8slice ser); + +LDKCVec_u8Z ErrorMessage_write(const LDKErrorMessage *obj); + +LDKErrorMessage ErrorMessage_read(LDKu8slice ser); + +LDKCVec_u8Z UnsignedNodeAnnouncement_write(const LDKUnsignedNodeAnnouncement *obj); + +LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_read(LDKu8slice ser); + +LDKCVec_u8Z NodeAnnouncement_write(const LDKNodeAnnouncement *obj); + +LDKNodeAnnouncement NodeAnnouncement_read(LDKu8slice ser); + +void MessageHandler_free(LDKMessageHandler this_ptr); + +/** + * A message handler which handles messages specific to channels. Usually this is just a + * ChannelManager object. + */ +const LDKChannelMessageHandler *MessageHandler_get_chan_handler(const LDKMessageHandler *this_ptr); + +/** + * A message handler which handles messages specific to channels. Usually this is just a + * ChannelManager object. + */ +void MessageHandler_set_chan_handler(LDKMessageHandler *this_ptr, LDKChannelMessageHandler val); + +/** + * A message handler which handles messages updating our knowledge of the network channel + * graph. Usually this is just a NetGraphMsgHandlerMonitor object. + */ +const LDKRoutingMessageHandler *MessageHandler_get_route_handler(const LDKMessageHandler *this_ptr); + +/** + * A message handler which handles messages updating our knowledge of the network channel + * graph. Usually this is just a NetGraphMsgHandlerMonitor object. + */ +void MessageHandler_set_route_handler(LDKMessageHandler *this_ptr, LDKRoutingMessageHandler val); + +MUST_USE_RES LDKMessageHandler MessageHandler_new(LDKChannelMessageHandler chan_handler_arg, LDKRoutingMessageHandler route_handler_arg); + +/** + * Calls the free function if one is set + */ +void SocketDescriptor_free(LDKSocketDescriptor this_ptr); + +void PeerHandleError_free(LDKPeerHandleError this_ptr); + +/** + * Used to indicate that we probably can't make any future connections to this peer, implying + * we should go ahead and force-close any channels we have with it. + */ +bool PeerHandleError_get_no_connection_possible(const LDKPeerHandleError *this_ptr); + +/** + * Used to indicate that we probably can't make any future connections to this peer, implying + * we should go ahead and force-close any channels we have with it. + */ +void PeerHandleError_set_no_connection_possible(LDKPeerHandleError *this_ptr, bool val); + +MUST_USE_RES LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg); + +void PeerManager_free(LDKPeerManager this_ptr); + +/** + * Constructs a new PeerManager with the given message handlers and node_id secret key + * ephemeral_random_data is used to derive per-connection ephemeral keys and must be + * cryptographically secure random bytes. + */ +MUST_USE_RES LDKPeerManager PeerManager_new(LDKMessageHandler message_handler, LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], LDKLogger logger); + +/** + * Get the list of node ids for peers which have completed the initial handshake. + * + * For outbound connections, this will be the same as the their_node_id parameter passed in to + * new_outbound_connection, however entries will only appear once the initial handshake has + * completed and we are sure the remote peer has the private key for the given node_id. + */ +MUST_USE_RES LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const LDKPeerManager *this_arg); + +/** + * Indicates a new outbound connection has been established to a node with the given node_id. + * Note that if an Err is returned here you MUST NOT call socket_disconnected for the new + * descriptor but must disconnect the connection immediately. + * + * Returns a small number of bytes to send to the remote node (currently always 50). + * + * Panics if descriptor is duplicative with some other descriptor which has not yet had a + * socket_disconnected(). + */ +MUST_USE_RES LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const LDKPeerManager *this_arg, LDKPublicKey their_node_id, LDKSocketDescriptor descriptor); + +/** + * Indicates a new inbound connection has been established. + * + * May refuse the connection by returning an Err, but will never write bytes to the remote end + * (outbound connector always speaks first). Note that if an Err is returned here you MUST NOT + * call socket_disconnected for the new descriptor but must disconnect the connection + * immediately. + * + * Panics if descriptor is duplicative with some other descriptor which has not yet had + * socket_disconnected called. + */ +MUST_USE_RES LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const LDKPeerManager *this_arg, LDKSocketDescriptor descriptor); + +/** + * Indicates that there is room to write data to the given socket descriptor. + * + * May return an Err to indicate that the connection should be closed. + * + * Will most likely call send_data on the descriptor passed in (or the descriptor handed into + * new_*\\_connection) before returning. Thus, be very careful with reentrancy issues! The + * invariants around calling write_buffer_space_avail in case a write did not fully complete + * must still hold - be ready to call write_buffer_space_avail again if a write call generated + * here isn't sufficient! Panics if the descriptor was not previously registered in a + * new_\\*_connection event. + */ +MUST_USE_RES LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const LDKPeerManager *this_arg, LDKSocketDescriptor *descriptor); + +/** + * Indicates that data was read from the given socket descriptor. + * + * May return an Err to indicate that the connection should be closed. + * + * Will *not* call back into send_data on any descriptors to avoid reentrancy complexity. + * Thus, however, you almost certainly want to call process_events() after any read_event to + * generate send_data calls to handle responses. + * + * If Ok(true) is returned, further read_events should not be triggered until a send_data call + * on this file descriptor has resume_read set (preventing DoS issues in the send buffer). + * + * Panics if the descriptor was not previously registered in a new_*_connection event. + */ +MUST_USE_RES LDKCResult_boolPeerHandleErrorZ PeerManager_read_event(const LDKPeerManager *this_arg, LDKSocketDescriptor *peer_descriptor, LDKu8slice data); + +/** + * Checks for any events generated by our handlers and processes them. Includes sending most + * response messages as well as messages generated by calls to handler functions directly (eg + * functions like ChannelManager::process_pending_htlc_forward or send_payment). + */ +void PeerManager_process_events(const LDKPeerManager *this_arg); + +/** + * Indicates that the given socket descriptor's connection is now closed. + * + * This must only be called if the socket has been disconnected by the peer or your own + * decision to disconnect it and must NOT be called in any case where other parts of this + * library (eg PeerHandleError, explicit disconnect_socket calls) instruct you to disconnect + * the peer. + * + * Panics if the descriptor was not previously registered in a successful new_*_connection event. + */ +void PeerManager_socket_disconnected(const LDKPeerManager *this_arg, const LDKSocketDescriptor *descriptor); + +/** + * This function should be called roughly once every 30 seconds. + * It will send pings to each peer and disconnect those which did not respond to the last round of pings. + * Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues! + */ +void PeerManager_timer_tick_occured(const LDKPeerManager *this_arg); + +/** + * Build the commitment secret from the seed and the commitment number + */ +LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx); + +/** + * Derives a per-commitment-transaction private key (eg an htlc key or delayed_payment key) + * from the base secret and the per_commitment_point. + * + * Note that this is infallible iff we trust that at least one of the two input keys are randomly + * generated (ie our own). + */ +LDKCResult_SecretKeySecpErrorZ derive_private_key(LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]); + +/** + * Derives a per-commitment-transaction public key (eg an htlc key or a delayed_payment key) + * from the base point and the per_commitment_key. This is the public equivalent of + * derive_private_key - using only public keys to derive a public key instead of private keys. + * + * Note that this is infallible iff we trust that at least one of the two input keys are randomly + * generated (ie our own). + */ +LDKCResult_PublicKeySecpErrorZ derive_public_key(LDKPublicKey per_commitment_point, LDKPublicKey base_point); + +/** + * Derives a per-commitment-transaction revocation key from its constituent parts. + * + * Note that this is infallible iff we trust that at least one of the two input keys are randomly + * generated (ie our own). + */ +LDKCResult_SecretKeySecpErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*revocation_base_secret)[32]); + +/** + * Derives a per-commitment-transaction revocation public key from its constituent parts. This is + * the public equivalend of derive_private_revocation_key - using only public keys to derive a + * public key instead of private keys. + * + * Note that this is infallible iff we trust that at least one of the two input keys are randomly + * generated (ie our own). + */ +LDKCResult_PublicKeySecpErrorZ derive_public_revocation_key(LDKPublicKey per_commitment_point, LDKPublicKey revocation_base_point); + +void TxCreationKeys_free(LDKTxCreationKeys this_ptr); + +/** + * The per-commitment public key which was used to derive the other keys. + */ +LDKPublicKey TxCreationKeys_get_per_commitment_point(const LDKTxCreationKeys *this_ptr); + +/** + * The per-commitment public key which was used to derive the other keys. + */ +void TxCreationKeys_set_per_commitment_point(LDKTxCreationKeys *this_ptr, LDKPublicKey val); + +/** + * The revocation key which is used to allow the owner of the commitment transaction to + * provide their counterparty the ability to punish them if they broadcast an old state. + */ +LDKPublicKey TxCreationKeys_get_revocation_key(const LDKTxCreationKeys *this_ptr); + +/** + * The revocation key which is used to allow the owner of the commitment transaction to + * provide their counterparty the ability to punish them if they broadcast an old state. + */ +void TxCreationKeys_set_revocation_key(LDKTxCreationKeys *this_ptr, LDKPublicKey val); + +/** + * A's HTLC Key + */ +LDKPublicKey TxCreationKeys_get_a_htlc_key(const LDKTxCreationKeys *this_ptr); + +/** + * A's HTLC Key + */ +void TxCreationKeys_set_a_htlc_key(LDKTxCreationKeys *this_ptr, LDKPublicKey val); + +/** + * B's HTLC Key + */ +LDKPublicKey TxCreationKeys_get_b_htlc_key(const LDKTxCreationKeys *this_ptr); + +/** + * B's HTLC Key + */ +void TxCreationKeys_set_b_htlc_key(LDKTxCreationKeys *this_ptr, LDKPublicKey val); + +/** + * A's Payment Key (which isn't allowed to be spent from for some delay) + */ +LDKPublicKey TxCreationKeys_get_a_delayed_payment_key(const LDKTxCreationKeys *this_ptr); + +/** + * A's Payment Key (which isn't allowed to be spent from for some delay) + */ +void TxCreationKeys_set_a_delayed_payment_key(LDKTxCreationKeys *this_ptr, LDKPublicKey val); + +MUST_USE_RES LDKTxCreationKeys TxCreationKeys_new(LDKPublicKey per_commitment_point_arg, LDKPublicKey revocation_key_arg, LDKPublicKey a_htlc_key_arg, LDKPublicKey b_htlc_key_arg, LDKPublicKey a_delayed_payment_key_arg); + +LDKCVec_u8Z TxCreationKeys_write(const LDKTxCreationKeys *obj); + +LDKTxCreationKeys TxCreationKeys_read(LDKu8slice ser); + +void PreCalculatedTxCreationKeys_free(LDKPreCalculatedTxCreationKeys this_ptr); + +/** + * Create a new PreCalculatedTxCreationKeys from TxCreationKeys + */ +MUST_USE_RES LDKPreCalculatedTxCreationKeys PreCalculatedTxCreationKeys_new(LDKTxCreationKeys keys); + +/** + * The pre-calculated transaction creation public keys. + * An external validating signer should not trust these keys. + */ +MUST_USE_RES LDKTxCreationKeys PreCalculatedTxCreationKeys_trust_key_derivation(const LDKPreCalculatedTxCreationKeys *this_arg); + +/** + * The transaction per-commitment point + */ +MUST_USE_RES LDKPublicKey PreCalculatedTxCreationKeys_per_commitment_point(const LDKPreCalculatedTxCreationKeys *this_arg); + +void ChannelPublicKeys_free(LDKChannelPublicKeys this_ptr); + +/** + * The public key which is used to sign all commitment transactions, as it appears in the + * on-chain channel lock-in 2-of-2 multisig output. + */ +LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const LDKChannelPublicKeys *this_ptr); + +/** + * The public key which is used to sign all commitment transactions, as it appears in the + * on-chain channel lock-in 2-of-2 multisig output. + */ +void ChannelPublicKeys_set_funding_pubkey(LDKChannelPublicKeys *this_ptr, LDKPublicKey val); + +/** + * The base point which is used (with derive_public_revocation_key) to derive per-commitment + * revocation keys. This is combined with the per-commitment-secret generated by the + * counterparty to create a secret which the counterparty can reveal to revoke previous + * states. + */ +LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const LDKChannelPublicKeys *this_ptr); + +/** + * The base point which is used (with derive_public_revocation_key) to derive per-commitment + * revocation keys. This is combined with the per-commitment-secret generated by the + * counterparty to create a secret which the counterparty can reveal to revoke previous + * states. + */ +void ChannelPublicKeys_set_revocation_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val); + +/** + * The public key which receives our immediately spendable primary channel balance in + * remote-broadcasted commitment transactions. This key is static across every commitment + * transaction. + */ +LDKPublicKey ChannelPublicKeys_get_payment_point(const LDKChannelPublicKeys *this_ptr); + +/** + * The public key which receives our immediately spendable primary channel balance in + * remote-broadcasted commitment transactions. This key is static across every commitment + * transaction. + */ +void ChannelPublicKeys_set_payment_point(LDKChannelPublicKeys *this_ptr, LDKPublicKey val); + +/** + * The base point which is used (with derive_public_key) to derive a per-commitment payment + * public key which receives non-HTLC-encumbered funds which are only available for spending + * after some delay (or can be claimed via the revocation path). + */ +LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const LDKChannelPublicKeys *this_ptr); + +/** + * The base point which is used (with derive_public_key) to derive a per-commitment payment + * public key which receives non-HTLC-encumbered funds which are only available for spending + * after some delay (or can be claimed via the revocation path). + */ +void ChannelPublicKeys_set_delayed_payment_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val); + +/** + * The base point which is used (with derive_public_key) to derive a per-commitment public key + * which is used to encumber HTLC-in-flight outputs. + */ +LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const LDKChannelPublicKeys *this_ptr); + +/** + * The base point which is used (with derive_public_key) to derive a per-commitment public key + * which is used to encumber HTLC-in-flight outputs. + */ +void ChannelPublicKeys_set_htlc_basepoint(LDKChannelPublicKeys *this_ptr, LDKPublicKey val); + +MUST_USE_RES LDKChannelPublicKeys ChannelPublicKeys_new(LDKPublicKey funding_pubkey_arg, LDKPublicKey revocation_basepoint_arg, LDKPublicKey payment_point_arg, LDKPublicKey delayed_payment_basepoint_arg, LDKPublicKey htlc_basepoint_arg); + +LDKCVec_u8Z ChannelPublicKeys_write(const LDKChannelPublicKeys *obj); + +LDKChannelPublicKeys ChannelPublicKeys_read(LDKu8slice ser); + +/** + * Create a new TxCreationKeys from channel base points and the per-commitment point + */ +MUST_USE_RES LDKCResult_TxCreationKeysSecpErrorZ TxCreationKeys_derive_new(LDKPublicKey per_commitment_point, LDKPublicKey a_delayed_payment_base, LDKPublicKey a_htlc_base, LDKPublicKey b_revocation_base, LDKPublicKey b_htlc_base); + +/** + * A script either spendable by the revocation + * key or the delayed_payment_key and satisfying the relative-locktime OP_CSV constrain. + * Encumbering a `to_local` output on a commitment transaction or 2nd-stage HTLC transactions. + */ +LDKCVec_u8Z get_revokeable_redeemscript(LDKPublicKey revocation_key, uint16_t to_self_delay, LDKPublicKey delayed_payment_key); + +void HTLCOutputInCommitment_free(LDKHTLCOutputInCommitment this_ptr); + +/** + * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction). + * Note that this is not the same as whether it is ountbound *from us*. To determine that you + * need to compare this value to whether the commitment transaction in question is that of + * the remote party or our own. + */ +bool HTLCOutputInCommitment_get_offered(const LDKHTLCOutputInCommitment *this_ptr); + +/** + * Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction). + * Note that this is not the same as whether it is ountbound *from us*. To determine that you + * need to compare this value to whether the commitment transaction in question is that of + * the remote party or our own. + */ +void HTLCOutputInCommitment_set_offered(LDKHTLCOutputInCommitment *this_ptr, bool val); + +/** + * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is + * this divided by 1000. + */ +uint64_t HTLCOutputInCommitment_get_amount_msat(const LDKHTLCOutputInCommitment *this_ptr); + +/** + * The value, in msat, of the HTLC. The value as it appears in the commitment transaction is + * this divided by 1000. + */ +void HTLCOutputInCommitment_set_amount_msat(LDKHTLCOutputInCommitment *this_ptr, uint64_t val); + +/** + * The CLTV lock-time at which this HTLC expires. + */ +uint32_t HTLCOutputInCommitment_get_cltv_expiry(const LDKHTLCOutputInCommitment *this_ptr); + +/** + * The CLTV lock-time at which this HTLC expires. + */ +void HTLCOutputInCommitment_set_cltv_expiry(LDKHTLCOutputInCommitment *this_ptr, uint32_t val); + +/** + * The hash of the preimage which unlocks this HTLC. + */ +const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const LDKHTLCOutputInCommitment *this_ptr))[32]; + +/** + * The hash of the preimage which unlocks this HTLC. + */ +void HTLCOutputInCommitment_set_payment_hash(LDKHTLCOutputInCommitment *this_ptr, LDKThirtyTwoBytes val); + +LDKCVec_u8Z HTLCOutputInCommitment_write(const LDKHTLCOutputInCommitment *obj); + +LDKHTLCOutputInCommitment HTLCOutputInCommitment_read(LDKu8slice ser); + +/** + * note here that 'a_revocation_key' is generated using b_revocation_basepoint and a's + * commitment secret. 'htlc' does *not* need to have its previous_output_index filled. + */ +LDKCVec_u8Z get_htlc_redeemscript(const LDKHTLCOutputInCommitment *htlc, const LDKTxCreationKeys *keys); + +/** + * Gets the redeemscript for a funding output from the two funding public keys. + * Note that the order of funding public keys does not matter. + */ +LDKCVec_u8Z make_funding_redeemscript(LDKPublicKey a, LDKPublicKey b); + +/** + * panics if htlc.transaction_output_index.is_none()! + */ +LDKCVec_u8Z build_htlc_transaction(const uint8_t (*prev_hash)[32], uint32_t feerate_per_kw, uint16_t to_self_delay, const LDKHTLCOutputInCommitment *htlc, LDKPublicKey a_delayed_payment_key, LDKPublicKey revocation_key); + +void LocalCommitmentTransaction_free(LDKLocalCommitmentTransaction this_ptr); + +/** + * The commitment transaction itself, in unsigned form. + */ +LDKCVec_u8Z LocalCommitmentTransaction_get_unsigned_tx(const LDKLocalCommitmentTransaction *this_ptr); + +/** + * The commitment transaction itself, in unsigned form. + */ +void LocalCommitmentTransaction_set_unsigned_tx(LDKLocalCommitmentTransaction *this_ptr, LDKCVec_u8Z val); + +/** + * Our counterparty's signature for the transaction, above. + */ +LDKSignature LocalCommitmentTransaction_get_their_sig(const LDKLocalCommitmentTransaction *this_ptr); + +/** + * Our counterparty's signature for the transaction, above. + */ +void LocalCommitmentTransaction_set_their_sig(LDKLocalCommitmentTransaction *this_ptr, LDKSignature val); + +/** + * The feerate paid per 1000-weight-unit in this commitment transaction. This value is + * controlled by the channel initiator. + */ +uint32_t LocalCommitmentTransaction_get_feerate_per_kw(const LDKLocalCommitmentTransaction *this_ptr); + +/** + * The feerate paid per 1000-weight-unit in this commitment transaction. This value is + * controlled by the channel initiator. + */ +void LocalCommitmentTransaction_set_feerate_per_kw(LDKLocalCommitmentTransaction *this_ptr, uint32_t val); + +/** + * The HTLCs and remote htlc signatures which were included in this commitment transaction. + * + * Note that this includes all HTLCs, including ones which were considered dust and not + * actually included in the transaction as it appears on-chain, but who's value is burned as + * fees and not included in the to_local or to_remote outputs. + * + * The remote HTLC signatures in the second element will always be set for non-dust HTLCs, ie + * those for which transaction_output_index.is_some(). + */ +void LocalCommitmentTransaction_set_per_htlc(LDKLocalCommitmentTransaction *this_ptr, LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ val); + +/** + * Generate a new LocalCommitmentTransaction based on a raw commitment transaction, + * remote signature and both parties keys. + * + * The unsigned transaction outputs must be consistent with htlc_data. This function + * only checks that the shape and amounts are consistent, but does not check the scriptPubkey. + */ +MUST_USE_RES LDKLocalCommitmentTransaction LocalCommitmentTransaction_new_missing_local_sig(LDKCVec_u8Z unsigned_tx, LDKSignature their_sig, LDKPublicKey our_funding_key, LDKPublicKey their_funding_key, LDKTxCreationKeys local_keys, uint32_t feerate_per_kw, LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ htlc_data); + +/** + * The pre-calculated transaction creation public keys. + * An external validating signer should not trust these keys. + */ +MUST_USE_RES LDKTxCreationKeys LocalCommitmentTransaction_trust_key_derivation(const LDKLocalCommitmentTransaction *this_arg); + +/** + * Get the txid of the local commitment transaction contained in this + * LocalCommitmentTransaction + */ +MUST_USE_RES LDKThirtyTwoBytes LocalCommitmentTransaction_txid(const LDKLocalCommitmentTransaction *this_arg); + +/** + * Gets our signature for the contained commitment transaction given our funding private key. + * + * Funding key is your key included in the 2-2 funding_outpoint lock. Should be provided + * by your ChannelKeys. + * Funding redeemscript is script locking funding_outpoint. This is the mutlsig script + * between your own funding key and your counterparty's. Currently, this is provided in + * ChannelKeys::sign_local_commitment() calls directly. + * Channel value is amount locked in funding_outpoint. + */ +MUST_USE_RES LDKSignature LocalCommitmentTransaction_get_local_sig(const LDKLocalCommitmentTransaction *this_arg, const uint8_t (*funding_key)[32], LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis); + +/** + * Get a signature for each HTLC which was included in the commitment transaction (ie for + * which HTLCOutputInCommitment::transaction_output_index.is_some()). + * + * The returned Vec has one entry for each HTLC, and in the same order. For HTLCs which were + * considered dust and not included, a None entry exists, for all others a signature is + * included. + */ +MUST_USE_RES LDKCResult_CVec_SignatureZNoneZ LocalCommitmentTransaction_get_htlc_sigs(const LDKLocalCommitmentTransaction *this_arg, const uint8_t (*htlc_base_key)[32], uint16_t local_csv); + +LDKCVec_u8Z LocalCommitmentTransaction_write(const LDKLocalCommitmentTransaction *obj); + +LDKLocalCommitmentTransaction LocalCommitmentTransaction_read(LDKu8slice ser); + +void InitFeatures_free(LDKInitFeatures this_ptr); + +void NodeFeatures_free(LDKNodeFeatures this_ptr); + +void ChannelFeatures_free(LDKChannelFeatures this_ptr); + +void RouteHop_free(LDKRouteHop this_ptr); + +/** + * The node_id of the node at this hop. + */ +LDKPublicKey RouteHop_get_pubkey(const LDKRouteHop *this_ptr); + +/** + * The node_id of the node at this hop. + */ +void RouteHop_set_pubkey(LDKRouteHop *this_ptr, LDKPublicKey val); + +/** + * The channel that should be used from the previous hop to reach this node. + */ +uint64_t RouteHop_get_short_channel_id(const LDKRouteHop *this_ptr); + +/** + * The channel that should be used from the previous hop to reach this node. + */ +void RouteHop_set_short_channel_id(LDKRouteHop *this_ptr, uint64_t val); + +/** + * The fee taken on this hop. For the last hop, this should be the full value of the payment. + */ +uint64_t RouteHop_get_fee_msat(const LDKRouteHop *this_ptr); + +/** + * The fee taken on this hop. For the last hop, this should be the full value of the payment. + */ +void RouteHop_set_fee_msat(LDKRouteHop *this_ptr, uint64_t val); + +/** + * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value + * expected at the destination, in excess of the current block height. + */ +uint32_t RouteHop_get_cltv_expiry_delta(const LDKRouteHop *this_ptr); + +/** + * The CLTV delta added for this hop. For the last hop, this should be the full CLTV value + * expected at the destination, in excess of the current block height. + */ +void RouteHop_set_cltv_expiry_delta(LDKRouteHop *this_ptr, uint32_t val); + +void Route_free(LDKRoute this_ptr); + +/** + * The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the + * last RouteHop in each path must be the same. + * Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the + * destination. Thus, this must always be at least length one. While the maximum length of any + * given path is variable, keeping the length of any path to less than 20 should currently + * ensure it is viable. + */ +void Route_set_paths(LDKRoute *this_ptr, LDKCVec_CVec_RouteHopZZ val); + +MUST_USE_RES LDKRoute Route_new(LDKCVec_CVec_RouteHopZZ paths_arg); + +LDKCVec_u8Z Route_write(const LDKRoute *obj); + +LDKRoute Route_read(LDKu8slice ser); + +void RouteHint_free(LDKRouteHint this_ptr); + +/** + * The node_id of the non-target end of the route + */ +LDKPublicKey RouteHint_get_src_node_id(const LDKRouteHint *this_ptr); + +/** + * The node_id of the non-target end of the route + */ +void RouteHint_set_src_node_id(LDKRouteHint *this_ptr, LDKPublicKey val); + +/** + * The short_channel_id of this channel + */ +uint64_t RouteHint_get_short_channel_id(const LDKRouteHint *this_ptr); + +/** + * The short_channel_id of this channel + */ +void RouteHint_set_short_channel_id(LDKRouteHint *this_ptr, uint64_t val); + +/** + * The fees which must be paid to use this channel + */ +LDKRoutingFees RouteHint_get_fees(const LDKRouteHint *this_ptr); + +/** + * The fees which must be paid to use this channel + */ +void RouteHint_set_fees(LDKRouteHint *this_ptr, LDKRoutingFees val); + +/** + * The difference in CLTV values between this node and the next node. + */ +uint16_t RouteHint_get_cltv_expiry_delta(const LDKRouteHint *this_ptr); + +/** + * The difference in CLTV values between this node and the next node. + */ +void RouteHint_set_cltv_expiry_delta(LDKRouteHint *this_ptr, uint16_t val); + +/** + * The minimum value, in msat, which must be relayed to the next hop. + */ +uint64_t RouteHint_get_htlc_minimum_msat(const LDKRouteHint *this_ptr); + +/** + * The minimum value, in msat, which must be relayed to the next hop. + */ +void RouteHint_set_htlc_minimum_msat(LDKRouteHint *this_ptr, uint64_t val); + +MUST_USE_RES LDKRouteHint RouteHint_new(LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg); + +/** + * Gets a route from us to the given target node. + * + * Extra routing hops between known nodes and the target will be used if they are included in + * last_hops. + * + * If some channels aren't announced, it may be useful to fill in a first_hops with the + * results from a local ChannelManager::list_usable_channels() call. If it is filled in, our + * view of our local channels (from net_graph_msg_handler) will be ignored, and only those in first_hops + * will be used. + * + * Panics if first_hops contains channels without short_channel_ids + * (ChannelManager::list_usable_channels will never include such channels). + * + * The fees on channels from us to next-hops are ignored (as they are assumed to all be + * equal), however the enabled/disabled bit on such channels as well as the htlc_minimum_msat + * *is* checked as they may change based on the receiving node. + */ +LDKCResult_RouteLightningErrorZ get_route(LDKPublicKey our_node_id, const LDKNetworkGraph *network, LDKPublicKey target, LDKCVec_ChannelDetailsZ *first_hops, LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, LDKLogger logger); + +void NetworkGraph_free(LDKNetworkGraph this_ptr); + +void LockedNetworkGraph_free(LDKLockedNetworkGraph this_ptr); + +void NetGraphMsgHandler_free(LDKNetGraphMsgHandler this_ptr); + +/** + * Creates a new tracker of the actual state of the network of channels and nodes, + * assuming a fresh network graph. + * Chain monitor is used to make sure announced channels exist on-chain, + * channel data is correct, and that the announcement is signed with + * channel owners' keys. + */ +MUST_USE_RES LDKNetGraphMsgHandler NetGraphMsgHandler_new(LDKChainWatchInterface chain_monitor, LDKLogger logger); + +/** + * Creates a new tracker of the actual state of the network of channels and nodes, + * assuming an existing Network Graph. + */ +MUST_USE_RES LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(LDKChainWatchInterface chain_monitor, LDKLogger logger, LDKNetworkGraph network_graph); + +/** + * Take a read lock on the network_graph and return it in the C-bindings + * newtype helper. This is likely only useful when called via the C + * bindings as you can call `self.network_graph.read().unwrap()` in Rust + * yourself. + */ +MUST_USE_RES LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const LDKNetGraphMsgHandler *this_arg); + +/** + * Get a reference to the NetworkGraph which this read-lock contains. + */ +MUST_USE_RES LDKNetworkGraph LockedNetworkGraph_graph(const LDKLockedNetworkGraph *this_arg); + +LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const LDKNetGraphMsgHandler *this_arg); + +void DirectionalChannelInfo_free(LDKDirectionalChannelInfo this_ptr); + +/** + * When the last update to the channel direction was issued. + * Value is opaque, as set in the announcement. + */ +uint32_t DirectionalChannelInfo_get_last_update(const LDKDirectionalChannelInfo *this_ptr); + +/** + * When the last update to the channel direction was issued. + * Value is opaque, as set in the announcement. + */ +void DirectionalChannelInfo_set_last_update(LDKDirectionalChannelInfo *this_ptr, uint32_t val); + +/** + * Whether the channel can be currently used for payments (in this one direction). + */ +bool DirectionalChannelInfo_get_enabled(const LDKDirectionalChannelInfo *this_ptr); + +/** + * Whether the channel can be currently used for payments (in this one direction). + */ +void DirectionalChannelInfo_set_enabled(LDKDirectionalChannelInfo *this_ptr, bool val); + +/** + * The difference in CLTV values that you must have when routing through this channel. + */ +uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const LDKDirectionalChannelInfo *this_ptr); + +/** + * The difference in CLTV values that you must have when routing through this channel. + */ +void DirectionalChannelInfo_set_cltv_expiry_delta(LDKDirectionalChannelInfo *this_ptr, uint16_t val); + +/** + * The minimum value, which must be relayed to the next hop via the channel + */ +uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const LDKDirectionalChannelInfo *this_ptr); + +/** + * The minimum value, which must be relayed to the next hop via the channel + */ +void DirectionalChannelInfo_set_htlc_minimum_msat(LDKDirectionalChannelInfo *this_ptr, uint64_t val); + +/** + * Most recent update for the channel received from the network + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +LDKChannelUpdate DirectionalChannelInfo_get_last_update_message(const LDKDirectionalChannelInfo *this_ptr); + +/** + * Most recent update for the channel received from the network + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +void DirectionalChannelInfo_set_last_update_message(LDKDirectionalChannelInfo *this_ptr, LDKChannelUpdate val); + +LDKCVec_u8Z DirectionalChannelInfo_write(const LDKDirectionalChannelInfo *obj); + +LDKDirectionalChannelInfo DirectionalChannelInfo_read(LDKu8slice ser); + +void ChannelInfo_free(LDKChannelInfo this_ptr); + +/** + * Source node of the first direction of a channel + */ +LDKPublicKey ChannelInfo_get_node_one(const LDKChannelInfo *this_ptr); + +/** + * Source node of the first direction of a channel + */ +void ChannelInfo_set_node_one(LDKChannelInfo *this_ptr, LDKPublicKey val); + +/** + * Details about the first direction of a channel + */ +LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const LDKChannelInfo *this_ptr); + +/** + * Details about the first direction of a channel + */ +void ChannelInfo_set_one_to_two(LDKChannelInfo *this_ptr, LDKDirectionalChannelInfo val); + +/** + * Source node of the second direction of a channel + */ +LDKPublicKey ChannelInfo_get_node_two(const LDKChannelInfo *this_ptr); + +/** + * Source node of the second direction of a channel + */ +void ChannelInfo_set_node_two(LDKChannelInfo *this_ptr, LDKPublicKey val); + +/** + * Details about the second direction of a channel + */ +LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const LDKChannelInfo *this_ptr); + +/** + * Details about the second direction of a channel + */ +void ChannelInfo_set_two_to_one(LDKChannelInfo *this_ptr, LDKDirectionalChannelInfo val); + +/** + * An initial announcement of the channel + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +LDKChannelAnnouncement ChannelInfo_get_announcement_message(const LDKChannelInfo *this_ptr); + +/** + * An initial announcement of the channel + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +void ChannelInfo_set_announcement_message(LDKChannelInfo *this_ptr, LDKChannelAnnouncement val); + +LDKCVec_u8Z ChannelInfo_write(const LDKChannelInfo *obj); + +LDKChannelInfo ChannelInfo_read(LDKu8slice ser); + +void RoutingFees_free(LDKRoutingFees this_ptr); + +/** + * Flat routing fee in satoshis + */ +uint32_t RoutingFees_get_base_msat(const LDKRoutingFees *this_ptr); + +/** + * Flat routing fee in satoshis + */ +void RoutingFees_set_base_msat(LDKRoutingFees *this_ptr, uint32_t val); + +/** + * Liquidity-based routing fee in millionths of a routed amount. + * In other words, 10000 is 1%. + */ +uint32_t RoutingFees_get_proportional_millionths(const LDKRoutingFees *this_ptr); + +/** + * Liquidity-based routing fee in millionths of a routed amount. + * In other words, 10000 is 1%. + */ +void RoutingFees_set_proportional_millionths(LDKRoutingFees *this_ptr, uint32_t val); + +MUST_USE_RES LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg); + +LDKRoutingFees RoutingFees_read(LDKu8slice ser); + +LDKCVec_u8Z RoutingFees_write(const LDKRoutingFees *obj); + +void NodeAnnouncementInfo_free(LDKNodeAnnouncementInfo this_ptr); + +/** + * When the last known update to the node state was issued. + * Value is opaque, as set in the announcement. + */ +uint32_t NodeAnnouncementInfo_get_last_update(const LDKNodeAnnouncementInfo *this_ptr); + +/** + * When the last known update to the node state was issued. + * Value is opaque, as set in the announcement. + */ +void NodeAnnouncementInfo_set_last_update(LDKNodeAnnouncementInfo *this_ptr, uint32_t val); + +/** + * Color assigned to the node + */ +const uint8_t (*NodeAnnouncementInfo_get_rgb(const LDKNodeAnnouncementInfo *this_ptr))[3]; + +/** + * Color assigned to the node + */ +void NodeAnnouncementInfo_set_rgb(LDKNodeAnnouncementInfo *this_ptr, LDKThreeBytes val); + +/** + * Moniker assigned to the node. + * May be invalid or malicious (eg control chars), + * should not be exposed to the user. + */ +const uint8_t (*NodeAnnouncementInfo_get_alias(const LDKNodeAnnouncementInfo *this_ptr))[32]; + +/** + * Moniker assigned to the node. + * May be invalid or malicious (eg control chars), + * should not be exposed to the user. + */ +void NodeAnnouncementInfo_set_alias(LDKNodeAnnouncementInfo *this_ptr, LDKThirtyTwoBytes val); + +/** + * Internet-level addresses via which one can connect to the node + */ +void NodeAnnouncementInfo_set_addresses(LDKNodeAnnouncementInfo *this_ptr, LDKCVec_NetAddressZ val); + +/** + * An initial announcement of the node + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const LDKNodeAnnouncementInfo *this_ptr); + +/** + * An initial announcement of the node + * Mostly redundant with the data we store in fields explicitly. + * Everything else is useful only for sending out for initial routing sync. + * Not stored if contains excess data to prevent DoS. + */ +void NodeAnnouncementInfo_set_announcement_message(LDKNodeAnnouncementInfo *this_ptr, LDKNodeAnnouncement val); + +LDKCVec_u8Z NodeAnnouncementInfo_write(const LDKNodeAnnouncementInfo *obj); + +LDKNodeAnnouncementInfo NodeAnnouncementInfo_read(LDKu8slice ser); + +void NodeInfo_free(LDKNodeInfo this_ptr); + +/** + * All valid channels a node has announced + */ +void NodeInfo_set_channels(LDKNodeInfo *this_ptr, LDKCVec_u64Z val); + +/** + * Lowest fees enabling routing via any of the enabled, known channels to a node. + * The two fields (flat and proportional fee) are independent, + * meaning they don't have to refer to the same channel. + */ +LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const LDKNodeInfo *this_ptr); + +/** + * Lowest fees enabling routing via any of the enabled, known channels to a node. + * The two fields (flat and proportional fee) are independent, + * meaning they don't have to refer to the same channel. + */ +void NodeInfo_set_lowest_inbound_channel_fees(LDKNodeInfo *this_ptr, LDKRoutingFees val); + +/** + * More information about a node from node_announcement. + * Optional because we store a Node entry after learning about it from + * a channel announcement, but before receiving a node announcement. + */ +LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const LDKNodeInfo *this_ptr); + +/** + * More information about a node from node_announcement. + * Optional because we store a Node entry after learning about it from + * a channel announcement, but before receiving a node announcement. + */ +void NodeInfo_set_announcement_info(LDKNodeInfo *this_ptr, LDKNodeAnnouncementInfo val); + +MUST_USE_RES LDKNodeInfo NodeInfo_new(LDKCVec_u64Z channels_arg, LDKRoutingFees lowest_inbound_channel_fees_arg, LDKNodeAnnouncementInfo announcement_info_arg); + +LDKCVec_u8Z NodeInfo_write(const LDKNodeInfo *obj); + +LDKNodeInfo NodeInfo_read(LDKu8slice ser); + +LDKCVec_u8Z NetworkGraph_write(const LDKNetworkGraph *obj); + +LDKNetworkGraph NetworkGraph_read(LDKu8slice ser); + +/** + * Creates a new, empty, network graph. + */ +MUST_USE_RES LDKNetworkGraph NetworkGraph_new(void); + +/** + * Close a channel if a corresponding HTLC fail was sent. + * If permanent, removes a channel from the local storage. + * May cause the removal of nodes too, if this was their last channel. + * If not permanent, makes channels unavailable for routing. + */ +void NetworkGraph_close_channel_from_update(LDKNetworkGraph *this_arg, uint64_t short_channel_id, bool is_permanent); + +/* Text to put at the end of the generated file */ diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp new file mode 100644 index 000000000..d494cd40c --- /dev/null +++ b/lightning-c-bindings/include/lightningpp.hpp @@ -0,0 +1,1987 @@ +#include +namespace LDK { +class Event { +private: + LDKEvent self; +public: + Event(const Event&) = delete; + ~Event() { Event_free(self); } + Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); } + Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); } + operator LDKEvent() { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; } + LDKEvent* operator &() { return &self; } + LDKEvent* operator ->() { return &self; } + const LDKEvent* operator &() const { return &self; } + const LDKEvent* operator ->() const { return &self; } +}; +class MessageSendEvent { +private: + LDKMessageSendEvent self; +public: + MessageSendEvent(const MessageSendEvent&) = delete; + ~MessageSendEvent() { MessageSendEvent_free(self); } + MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); } + MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); } + operator LDKMessageSendEvent() { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; } + LDKMessageSendEvent* operator &() { return &self; } + LDKMessageSendEvent* operator ->() { return &self; } + const LDKMessageSendEvent* operator &() const { return &self; } + const LDKMessageSendEvent* operator ->() const { return &self; } +}; +class MessageSendEventsProvider { +private: + LDKMessageSendEventsProvider self; +public: + MessageSendEventsProvider(const MessageSendEventsProvider&) = delete; + ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); } + MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); } + MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); } + operator LDKMessageSendEventsProvider() { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; } + LDKMessageSendEventsProvider* operator &() { return &self; } + LDKMessageSendEventsProvider* operator ->() { return &self; } + const LDKMessageSendEventsProvider* operator &() const { return &self; } + const LDKMessageSendEventsProvider* operator ->() const { return &self; } +}; +class EventsProvider { +private: + LDKEventsProvider self; +public: + EventsProvider(const EventsProvider&) = delete; + ~EventsProvider() { EventsProvider_free(self); } + EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); } + EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); } + operator LDKEventsProvider() { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; } + LDKEventsProvider* operator &() { return &self; } + LDKEventsProvider* operator ->() { return &self; } + const LDKEventsProvider* operator &() const { return &self; } + const LDKEventsProvider* operator ->() const { return &self; } +}; +class APIError { +private: + LDKAPIError self; +public: + APIError(const APIError&) = delete; + ~APIError() { APIError_free(self); } + APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); } + APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); } + operator LDKAPIError() { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; } + LDKAPIError* operator &() { return &self; } + LDKAPIError* operator ->() { return &self; } + const LDKAPIError* operator &() const { return &self; } + const LDKAPIError* operator ->() const { return &self; } +}; +class Level { +private: + LDKLevel self; +public: + Level(const Level&) = delete; + Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); } + Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); } + operator LDKLevel() { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; } + LDKLevel* operator &() { return &self; } + LDKLevel* operator ->() { return &self; } + const LDKLevel* operator &() const { return &self; } + const LDKLevel* operator ->() const { return &self; } +}; +class Logger { +private: + LDKLogger self; +public: + Logger(const Logger&) = delete; + ~Logger() { Logger_free(self); } + Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); } + Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); } + operator LDKLogger() { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; } + LDKLogger* operator &() { return &self; } + LDKLogger* operator ->() { return &self; } + const LDKLogger* operator &() const { return &self; } + const LDKLogger* operator ->() const { return &self; } +}; +class ChannelHandshakeConfig { +private: + LDKChannelHandshakeConfig self; +public: + ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete; + ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); } + ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); } + ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); } + operator LDKChannelHandshakeConfig() { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; } + LDKChannelHandshakeConfig* operator &() { return &self; } + LDKChannelHandshakeConfig* operator ->() { return &self; } + const LDKChannelHandshakeConfig* operator &() const { return &self; } + const LDKChannelHandshakeConfig* operator ->() const { return &self; } +}; +class ChannelHandshakeLimits { +private: + LDKChannelHandshakeLimits self; +public: + ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete; + ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); } + ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); } + ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); } + operator LDKChannelHandshakeLimits() { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; } + LDKChannelHandshakeLimits* operator &() { return &self; } + LDKChannelHandshakeLimits* operator ->() { return &self; } + const LDKChannelHandshakeLimits* operator &() const { return &self; } + const LDKChannelHandshakeLimits* operator ->() const { return &self; } +}; +class ChannelConfig { +private: + LDKChannelConfig self; +public: + ChannelConfig(const ChannelConfig&) = delete; + ~ChannelConfig() { ChannelConfig_free(self); } + ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); } + ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); } + operator LDKChannelConfig() { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; } + LDKChannelConfig* operator &() { return &self; } + LDKChannelConfig* operator ->() { return &self; } + const LDKChannelConfig* operator &() const { return &self; } + const LDKChannelConfig* operator ->() const { return &self; } +}; +class UserConfig { +private: + LDKUserConfig self; +public: + UserConfig(const UserConfig&) = delete; + ~UserConfig() { UserConfig_free(self); } + UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); } + UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); } + operator LDKUserConfig() { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; } + LDKUserConfig* operator &() { return &self; } + LDKUserConfig* operator ->() { return &self; } + const LDKUserConfig* operator &() const { return &self; } + const LDKUserConfig* operator ->() const { return &self; } +}; +class ChainError { +private: + LDKChainError self; +public: + ChainError(const ChainError&) = delete; + ChainError(ChainError&& o) : self(o.self) { memset(&o, 0, sizeof(ChainError)); } + ChainError(LDKChainError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainError)); } + operator LDKChainError() { LDKChainError res = self; memset(&self, 0, sizeof(LDKChainError)); return res; } + LDKChainError* operator &() { return &self; } + LDKChainError* operator ->() { return &self; } + const LDKChainError* operator &() const { return &self; } + const LDKChainError* operator ->() const { return &self; } +}; +class ChainWatchInterface { +private: + LDKChainWatchInterface self; +public: + ChainWatchInterface(const ChainWatchInterface&) = delete; + ~ChainWatchInterface() { ChainWatchInterface_free(self); } + ChainWatchInterface(ChainWatchInterface&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchInterface)); } + ChainWatchInterface(LDKChainWatchInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchInterface)); } + operator LDKChainWatchInterface() { LDKChainWatchInterface res = self; memset(&self, 0, sizeof(LDKChainWatchInterface)); return res; } + LDKChainWatchInterface* operator &() { return &self; } + LDKChainWatchInterface* operator ->() { return &self; } + const LDKChainWatchInterface* operator &() const { return &self; } + const LDKChainWatchInterface* operator ->() const { return &self; } +}; +class BroadcasterInterface { +private: + LDKBroadcasterInterface self; +public: + BroadcasterInterface(const BroadcasterInterface&) = delete; + ~BroadcasterInterface() { BroadcasterInterface_free(self); } + BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); } + BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); } + operator LDKBroadcasterInterface() { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; } + LDKBroadcasterInterface* operator &() { return &self; } + LDKBroadcasterInterface* operator ->() { return &self; } + const LDKBroadcasterInterface* operator &() const { return &self; } + const LDKBroadcasterInterface* operator ->() const { return &self; } +}; +class ChainListener { +private: + LDKChainListener self; +public: + ChainListener(const ChainListener&) = delete; + ~ChainListener() { ChainListener_free(self); } + ChainListener(ChainListener&& o) : self(o.self) { memset(&o, 0, sizeof(ChainListener)); } + ChainListener(LDKChainListener&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainListener)); } + operator LDKChainListener() { LDKChainListener res = self; memset(&self, 0, sizeof(LDKChainListener)); return res; } + LDKChainListener* operator &() { return &self; } + LDKChainListener* operator ->() { return &self; } + const LDKChainListener* operator &() const { return &self; } + const LDKChainListener* operator ->() const { return &self; } +}; +class ConfirmationTarget { +private: + LDKConfirmationTarget self; +public: + ConfirmationTarget(const ConfirmationTarget&) = delete; + ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); } + ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); } + operator LDKConfirmationTarget() { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; } + LDKConfirmationTarget* operator &() { return &self; } + LDKConfirmationTarget* operator ->() { return &self; } + const LDKConfirmationTarget* operator &() const { return &self; } + const LDKConfirmationTarget* operator ->() const { return &self; } +}; +class FeeEstimator { +private: + LDKFeeEstimator self; +public: + FeeEstimator(const FeeEstimator&) = delete; + ~FeeEstimator() { FeeEstimator_free(self); } + FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); } + FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); } + operator LDKFeeEstimator() { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; } + LDKFeeEstimator* operator &() { return &self; } + LDKFeeEstimator* operator ->() { return &self; } + const LDKFeeEstimator* operator &() const { return &self; } + const LDKFeeEstimator* operator ->() const { return &self; } +}; +class ChainWatchedUtil { +private: + LDKChainWatchedUtil self; +public: + ChainWatchedUtil(const ChainWatchedUtil&) = delete; + ~ChainWatchedUtil() { ChainWatchedUtil_free(self); } + ChainWatchedUtil(ChainWatchedUtil&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchedUtil)); } + ChainWatchedUtil(LDKChainWatchedUtil&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchedUtil)); } + operator LDKChainWatchedUtil() { LDKChainWatchedUtil res = self; memset(&self, 0, sizeof(LDKChainWatchedUtil)); return res; } + LDKChainWatchedUtil* operator &() { return &self; } + LDKChainWatchedUtil* operator ->() { return &self; } + const LDKChainWatchedUtil* operator &() const { return &self; } + const LDKChainWatchedUtil* operator ->() const { return &self; } +}; +class BlockNotifier { +private: + LDKBlockNotifier self; +public: + BlockNotifier(const BlockNotifier&) = delete; + ~BlockNotifier() { BlockNotifier_free(self); } + BlockNotifier(BlockNotifier&& o) : self(o.self) { memset(&o, 0, sizeof(BlockNotifier)); } + BlockNotifier(LDKBlockNotifier&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlockNotifier)); } + operator LDKBlockNotifier() { LDKBlockNotifier res = self; memset(&self, 0, sizeof(LDKBlockNotifier)); return res; } + LDKBlockNotifier* operator &() { return &self; } + LDKBlockNotifier* operator ->() { return &self; } + const LDKBlockNotifier* operator &() const { return &self; } + const LDKBlockNotifier* operator ->() const { return &self; } +}; +class ChainWatchInterfaceUtil { +private: + LDKChainWatchInterfaceUtil self; +public: + ChainWatchInterfaceUtil(const ChainWatchInterfaceUtil&) = delete; + ~ChainWatchInterfaceUtil() { ChainWatchInterfaceUtil_free(self); } + ChainWatchInterfaceUtil(ChainWatchInterfaceUtil&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchInterfaceUtil)); } + ChainWatchInterfaceUtil(LDKChainWatchInterfaceUtil&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchInterfaceUtil)); } + operator LDKChainWatchInterfaceUtil() { LDKChainWatchInterfaceUtil res = self; memset(&self, 0, sizeof(LDKChainWatchInterfaceUtil)); return res; } + LDKChainWatchInterfaceUtil* operator &() { return &self; } + LDKChainWatchInterfaceUtil* operator ->() { return &self; } + const LDKChainWatchInterfaceUtil* operator &() const { return &self; } + const LDKChainWatchInterfaceUtil* operator ->() const { return &self; } +}; +class OutPoint { +private: + LDKOutPoint self; +public: + OutPoint(const OutPoint&) = delete; + ~OutPoint() { OutPoint_free(self); } + OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); } + OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); } + operator LDKOutPoint() { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; } + LDKOutPoint* operator &() { return &self; } + LDKOutPoint* operator ->() { return &self; } + const LDKOutPoint* operator &() const { return &self; } + const LDKOutPoint* operator ->() const { return &self; } +}; +class SpendableOutputDescriptor { +private: + LDKSpendableOutputDescriptor self; +public: + SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete; + ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); } + SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); } + SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); } + operator LDKSpendableOutputDescriptor() { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; } + LDKSpendableOutputDescriptor* operator &() { return &self; } + LDKSpendableOutputDescriptor* operator ->() { return &self; } + const LDKSpendableOutputDescriptor* operator &() const { return &self; } + const LDKSpendableOutputDescriptor* operator ->() const { return &self; } +}; +class ChannelKeys { +private: + LDKChannelKeys self; +public: + ChannelKeys(const ChannelKeys&) = delete; + ~ChannelKeys() { ChannelKeys_free(self); } + ChannelKeys(ChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelKeys)); } + ChannelKeys(LDKChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelKeys)); } + operator LDKChannelKeys() { LDKChannelKeys res = self; memset(&self, 0, sizeof(LDKChannelKeys)); return res; } + LDKChannelKeys* operator &() { return &self; } + LDKChannelKeys* operator ->() { return &self; } + const LDKChannelKeys* operator &() const { return &self; } + const LDKChannelKeys* operator ->() const { return &self; } +}; +class KeysInterface { +private: + LDKKeysInterface self; +public: + KeysInterface(const KeysInterface&) = delete; + ~KeysInterface() { KeysInterface_free(self); } + KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); } + KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); } + operator LDKKeysInterface() { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; } + LDKKeysInterface* operator &() { return &self; } + LDKKeysInterface* operator ->() { return &self; } + const LDKKeysInterface* operator &() const { return &self; } + const LDKKeysInterface* operator ->() const { return &self; } +}; +class InMemoryChannelKeys { +private: + LDKInMemoryChannelKeys self; +public: + InMemoryChannelKeys(const InMemoryChannelKeys&) = delete; + ~InMemoryChannelKeys() { InMemoryChannelKeys_free(self); } + InMemoryChannelKeys(InMemoryChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(InMemoryChannelKeys)); } + InMemoryChannelKeys(LDKInMemoryChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemoryChannelKeys)); } + operator LDKInMemoryChannelKeys() { LDKInMemoryChannelKeys res = self; memset(&self, 0, sizeof(LDKInMemoryChannelKeys)); return res; } + LDKInMemoryChannelKeys* operator &() { return &self; } + LDKInMemoryChannelKeys* operator ->() { return &self; } + const LDKInMemoryChannelKeys* operator &() const { return &self; } + const LDKInMemoryChannelKeys* operator ->() const { return &self; } +}; +class KeysManager { +private: + LDKKeysManager self; +public: + KeysManager(const KeysManager&) = delete; + ~KeysManager() { KeysManager_free(self); } + KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); } + KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); } + operator LDKKeysManager() { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; } + LDKKeysManager* operator &() { return &self; } + LDKKeysManager* operator ->() { return &self; } + const LDKKeysManager* operator &() const { return &self; } + const LDKKeysManager* operator ->() const { return &self; } +}; +class ChannelManager { +private: + LDKChannelManager self; +public: + ChannelManager(const ChannelManager&) = delete; + ~ChannelManager() { ChannelManager_free(self); } + ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); } + ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); } + operator LDKChannelManager() { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; } + LDKChannelManager* operator &() { return &self; } + LDKChannelManager* operator ->() { return &self; } + const LDKChannelManager* operator &() const { return &self; } + const LDKChannelManager* operator ->() const { return &self; } +}; +class ChannelDetails { +private: + LDKChannelDetails self; +public: + ChannelDetails(const ChannelDetails&) = delete; + ~ChannelDetails() { ChannelDetails_free(self); } + ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); } + ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); } + operator LDKChannelDetails() { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; } + LDKChannelDetails* operator &() { return &self; } + LDKChannelDetails* operator ->() { return &self; } + const LDKChannelDetails* operator &() const { return &self; } + const LDKChannelDetails* operator ->() const { return &self; } +}; +class PaymentSendFailure { +private: + LDKPaymentSendFailure self; +public: + PaymentSendFailure(const PaymentSendFailure&) = delete; + ~PaymentSendFailure() { PaymentSendFailure_free(self); } + PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); } + PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); } + operator LDKPaymentSendFailure() { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; } + LDKPaymentSendFailure* operator &() { return &self; } + LDKPaymentSendFailure* operator ->() { return &self; } + const LDKPaymentSendFailure* operator &() const { return &self; } + const LDKPaymentSendFailure* operator ->() const { return &self; } +}; +class ChannelManagerReadArgs { +private: + LDKChannelManagerReadArgs self; +public: + ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete; + ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); } + ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); } + ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); } + operator LDKChannelManagerReadArgs() { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; } + LDKChannelManagerReadArgs* operator &() { return &self; } + LDKChannelManagerReadArgs* operator ->() { return &self; } + const LDKChannelManagerReadArgs* operator &() const { return &self; } + const LDKChannelManagerReadArgs* operator ->() const { return &self; } +}; +class ChannelMonitorUpdate { +private: + LDKChannelMonitorUpdate self; +public: + ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete; + ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); } + ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); } + ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); } + operator LDKChannelMonitorUpdate() { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; } + LDKChannelMonitorUpdate* operator &() { return &self; } + LDKChannelMonitorUpdate* operator ->() { return &self; } + const LDKChannelMonitorUpdate* operator &() const { return &self; } + const LDKChannelMonitorUpdate* operator ->() const { return &self; } +}; +class ChannelMonitorUpdateErr { +private: + LDKChannelMonitorUpdateErr self; +public: + ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete; + ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); } + ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); } + operator LDKChannelMonitorUpdateErr() { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; } + LDKChannelMonitorUpdateErr* operator &() { return &self; } + LDKChannelMonitorUpdateErr* operator ->() { return &self; } + const LDKChannelMonitorUpdateErr* operator &() const { return &self; } + const LDKChannelMonitorUpdateErr* operator ->() const { return &self; } +}; +class MonitorUpdateError { +private: + LDKMonitorUpdateError self; +public: + MonitorUpdateError(const MonitorUpdateError&) = delete; + ~MonitorUpdateError() { MonitorUpdateError_free(self); } + MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); } + MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); } + operator LDKMonitorUpdateError() { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; } + LDKMonitorUpdateError* operator &() { return &self; } + LDKMonitorUpdateError* operator ->() { return &self; } + const LDKMonitorUpdateError* operator &() const { return &self; } + const LDKMonitorUpdateError* operator ->() const { return &self; } +}; +class MonitorEvent { +private: + LDKMonitorEvent self; +public: + MonitorEvent(const MonitorEvent&) = delete; + ~MonitorEvent() { MonitorEvent_free(self); } + MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); } + MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); } + operator LDKMonitorEvent() { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; } + LDKMonitorEvent* operator &() { return &self; } + LDKMonitorEvent* operator ->() { return &self; } + const LDKMonitorEvent* operator &() const { return &self; } + const LDKMonitorEvent* operator ->() const { return &self; } +}; +class HTLCUpdate { +private: + LDKHTLCUpdate self; +public: + HTLCUpdate(const HTLCUpdate&) = delete; + ~HTLCUpdate() { HTLCUpdate_free(self); } + HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); } + HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); } + operator LDKHTLCUpdate() { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; } + LDKHTLCUpdate* operator &() { return &self; } + LDKHTLCUpdate* operator ->() { return &self; } + const LDKHTLCUpdate* operator &() const { return &self; } + const LDKHTLCUpdate* operator ->() const { return &self; } +}; +class ChannelMonitor { +private: + LDKChannelMonitor self; +public: + ChannelMonitor(const ChannelMonitor&) = delete; + ~ChannelMonitor() { ChannelMonitor_free(self); } + ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); } + ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); } + operator LDKChannelMonitor() { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; } + LDKChannelMonitor* operator &() { return &self; } + LDKChannelMonitor* operator ->() { return &self; } + const LDKChannelMonitor* operator &() const { return &self; } + const LDKChannelMonitor* operator ->() const { return &self; } +}; +class ManyChannelMonitor { +private: + LDKManyChannelMonitor self; +public: + ManyChannelMonitor(const ManyChannelMonitor&) = delete; + ~ManyChannelMonitor() { ManyChannelMonitor_free(self); } + ManyChannelMonitor(ManyChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ManyChannelMonitor)); } + ManyChannelMonitor(LDKManyChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKManyChannelMonitor)); } + operator LDKManyChannelMonitor() { LDKManyChannelMonitor res = self; memset(&self, 0, sizeof(LDKManyChannelMonitor)); return res; } + LDKManyChannelMonitor* operator &() { return &self; } + LDKManyChannelMonitor* operator ->() { return &self; } + const LDKManyChannelMonitor* operator &() const { return &self; } + const LDKManyChannelMonitor* operator ->() const { return &self; } +}; +class DecodeError { +private: + LDKDecodeError self; +public: + DecodeError(const DecodeError&) = delete; + ~DecodeError() { DecodeError_free(self); } + DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); } + DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); } + operator LDKDecodeError() { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; } + LDKDecodeError* operator &() { return &self; } + LDKDecodeError* operator ->() { return &self; } + const LDKDecodeError* operator &() const { return &self; } + const LDKDecodeError* operator ->() const { return &self; } +}; +class Init { +private: + LDKInit self; +public: + Init(const Init&) = delete; + ~Init() { Init_free(self); } + Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); } + Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); } + operator LDKInit() { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; } + LDKInit* operator &() { return &self; } + LDKInit* operator ->() { return &self; } + const LDKInit* operator &() const { return &self; } + const LDKInit* operator ->() const { return &self; } +}; +class ErrorMessage { +private: + LDKErrorMessage self; +public: + ErrorMessage(const ErrorMessage&) = delete; + ~ErrorMessage() { ErrorMessage_free(self); } + ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); } + ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); } + operator LDKErrorMessage() { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; } + LDKErrorMessage* operator &() { return &self; } + LDKErrorMessage* operator ->() { return &self; } + const LDKErrorMessage* operator &() const { return &self; } + const LDKErrorMessage* operator ->() const { return &self; } +}; +class Ping { +private: + LDKPing self; +public: + Ping(const Ping&) = delete; + ~Ping() { Ping_free(self); } + Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); } + Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); } + operator LDKPing() { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; } + LDKPing* operator &() { return &self; } + LDKPing* operator ->() { return &self; } + const LDKPing* operator &() const { return &self; } + const LDKPing* operator ->() const { return &self; } +}; +class Pong { +private: + LDKPong self; +public: + Pong(const Pong&) = delete; + ~Pong() { Pong_free(self); } + Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); } + Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); } + operator LDKPong() { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; } + LDKPong* operator &() { return &self; } + LDKPong* operator ->() { return &self; } + const LDKPong* operator &() const { return &self; } + const LDKPong* operator ->() const { return &self; } +}; +class OpenChannel { +private: + LDKOpenChannel self; +public: + OpenChannel(const OpenChannel&) = delete; + ~OpenChannel() { OpenChannel_free(self); } + OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); } + OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); } + operator LDKOpenChannel() { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; } + LDKOpenChannel* operator &() { return &self; } + LDKOpenChannel* operator ->() { return &self; } + const LDKOpenChannel* operator &() const { return &self; } + const LDKOpenChannel* operator ->() const { return &self; } +}; +class AcceptChannel { +private: + LDKAcceptChannel self; +public: + AcceptChannel(const AcceptChannel&) = delete; + ~AcceptChannel() { AcceptChannel_free(self); } + AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); } + AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); } + operator LDKAcceptChannel() { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; } + LDKAcceptChannel* operator &() { return &self; } + LDKAcceptChannel* operator ->() { return &self; } + const LDKAcceptChannel* operator &() const { return &self; } + const LDKAcceptChannel* operator ->() const { return &self; } +}; +class FundingCreated { +private: + LDKFundingCreated self; +public: + FundingCreated(const FundingCreated&) = delete; + ~FundingCreated() { FundingCreated_free(self); } + FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); } + FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); } + operator LDKFundingCreated() { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; } + LDKFundingCreated* operator &() { return &self; } + LDKFundingCreated* operator ->() { return &self; } + const LDKFundingCreated* operator &() const { return &self; } + const LDKFundingCreated* operator ->() const { return &self; } +}; +class FundingSigned { +private: + LDKFundingSigned self; +public: + FundingSigned(const FundingSigned&) = delete; + ~FundingSigned() { FundingSigned_free(self); } + FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); } + FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); } + operator LDKFundingSigned() { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; } + LDKFundingSigned* operator &() { return &self; } + LDKFundingSigned* operator ->() { return &self; } + const LDKFundingSigned* operator &() const { return &self; } + const LDKFundingSigned* operator ->() const { return &self; } +}; +class FundingLocked { +private: + LDKFundingLocked self; +public: + FundingLocked(const FundingLocked&) = delete; + ~FundingLocked() { FundingLocked_free(self); } + FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); } + FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); } + operator LDKFundingLocked() { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; } + LDKFundingLocked* operator &() { return &self; } + LDKFundingLocked* operator ->() { return &self; } + const LDKFundingLocked* operator &() const { return &self; } + const LDKFundingLocked* operator ->() const { return &self; } +}; +class Shutdown { +private: + LDKShutdown self; +public: + Shutdown(const Shutdown&) = delete; + ~Shutdown() { Shutdown_free(self); } + Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); } + Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); } + operator LDKShutdown() { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; } + LDKShutdown* operator &() { return &self; } + LDKShutdown* operator ->() { return &self; } + const LDKShutdown* operator &() const { return &self; } + const LDKShutdown* operator ->() const { return &self; } +}; +class ClosingSigned { +private: + LDKClosingSigned self; +public: + ClosingSigned(const ClosingSigned&) = delete; + ~ClosingSigned() { ClosingSigned_free(self); } + ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); } + ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); } + operator LDKClosingSigned() { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; } + LDKClosingSigned* operator &() { return &self; } + LDKClosingSigned* operator ->() { return &self; } + const LDKClosingSigned* operator &() const { return &self; } + const LDKClosingSigned* operator ->() const { return &self; } +}; +class UpdateAddHTLC { +private: + LDKUpdateAddHTLC self; +public: + UpdateAddHTLC(const UpdateAddHTLC&) = delete; + ~UpdateAddHTLC() { UpdateAddHTLC_free(self); } + UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); } + UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); } + operator LDKUpdateAddHTLC() { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; } + LDKUpdateAddHTLC* operator &() { return &self; } + LDKUpdateAddHTLC* operator ->() { return &self; } + const LDKUpdateAddHTLC* operator &() const { return &self; } + const LDKUpdateAddHTLC* operator ->() const { return &self; } +}; +class UpdateFulfillHTLC { +private: + LDKUpdateFulfillHTLC self; +public: + UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete; + ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); } + UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); } + UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); } + operator LDKUpdateFulfillHTLC() { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; } + LDKUpdateFulfillHTLC* operator &() { return &self; } + LDKUpdateFulfillHTLC* operator ->() { return &self; } + const LDKUpdateFulfillHTLC* operator &() const { return &self; } + const LDKUpdateFulfillHTLC* operator ->() const { return &self; } +}; +class UpdateFailHTLC { +private: + LDKUpdateFailHTLC self; +public: + UpdateFailHTLC(const UpdateFailHTLC&) = delete; + ~UpdateFailHTLC() { UpdateFailHTLC_free(self); } + UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); } + UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); } + operator LDKUpdateFailHTLC() { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; } + LDKUpdateFailHTLC* operator &() { return &self; } + LDKUpdateFailHTLC* operator ->() { return &self; } + const LDKUpdateFailHTLC* operator &() const { return &self; } + const LDKUpdateFailHTLC* operator ->() const { return &self; } +}; +class UpdateFailMalformedHTLC { +private: + LDKUpdateFailMalformedHTLC self; +public: + UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete; + ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); } + UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); } + UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); } + operator LDKUpdateFailMalformedHTLC() { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; } + LDKUpdateFailMalformedHTLC* operator &() { return &self; } + LDKUpdateFailMalformedHTLC* operator ->() { return &self; } + const LDKUpdateFailMalformedHTLC* operator &() const { return &self; } + const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; } +}; +class CommitmentSigned { +private: + LDKCommitmentSigned self; +public: + CommitmentSigned(const CommitmentSigned&) = delete; + ~CommitmentSigned() { CommitmentSigned_free(self); } + CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); } + CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); } + operator LDKCommitmentSigned() { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; } + LDKCommitmentSigned* operator &() { return &self; } + LDKCommitmentSigned* operator ->() { return &self; } + const LDKCommitmentSigned* operator &() const { return &self; } + const LDKCommitmentSigned* operator ->() const { return &self; } +}; +class RevokeAndACK { +private: + LDKRevokeAndACK self; +public: + RevokeAndACK(const RevokeAndACK&) = delete; + ~RevokeAndACK() { RevokeAndACK_free(self); } + RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); } + RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); } + operator LDKRevokeAndACK() { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; } + LDKRevokeAndACK* operator &() { return &self; } + LDKRevokeAndACK* operator ->() { return &self; } + const LDKRevokeAndACK* operator &() const { return &self; } + const LDKRevokeAndACK* operator ->() const { return &self; } +}; +class UpdateFee { +private: + LDKUpdateFee self; +public: + UpdateFee(const UpdateFee&) = delete; + ~UpdateFee() { UpdateFee_free(self); } + UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); } + UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); } + operator LDKUpdateFee() { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; } + LDKUpdateFee* operator &() { return &self; } + LDKUpdateFee* operator ->() { return &self; } + const LDKUpdateFee* operator &() const { return &self; } + const LDKUpdateFee* operator ->() const { return &self; } +}; +class DataLossProtect { +private: + LDKDataLossProtect self; +public: + DataLossProtect(const DataLossProtect&) = delete; + ~DataLossProtect() { DataLossProtect_free(self); } + DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); } + DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); } + operator LDKDataLossProtect() { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; } + LDKDataLossProtect* operator &() { return &self; } + LDKDataLossProtect* operator ->() { return &self; } + const LDKDataLossProtect* operator &() const { return &self; } + const LDKDataLossProtect* operator ->() const { return &self; } +}; +class ChannelReestablish { +private: + LDKChannelReestablish self; +public: + ChannelReestablish(const ChannelReestablish&) = delete; + ~ChannelReestablish() { ChannelReestablish_free(self); } + ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); } + ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); } + operator LDKChannelReestablish() { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; } + LDKChannelReestablish* operator &() { return &self; } + LDKChannelReestablish* operator ->() { return &self; } + const LDKChannelReestablish* operator &() const { return &self; } + const LDKChannelReestablish* operator ->() const { return &self; } +}; +class AnnouncementSignatures { +private: + LDKAnnouncementSignatures self; +public: + AnnouncementSignatures(const AnnouncementSignatures&) = delete; + ~AnnouncementSignatures() { AnnouncementSignatures_free(self); } + AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); } + AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); } + operator LDKAnnouncementSignatures() { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; } + LDKAnnouncementSignatures* operator &() { return &self; } + LDKAnnouncementSignatures* operator ->() { return &self; } + const LDKAnnouncementSignatures* operator &() const { return &self; } + const LDKAnnouncementSignatures* operator ->() const { return &self; } +}; +class NetAddress { +private: + LDKNetAddress self; +public: + NetAddress(const NetAddress&) = delete; + ~NetAddress() { NetAddress_free(self); } + NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); } + NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); } + operator LDKNetAddress() { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; } + LDKNetAddress* operator &() { return &self; } + LDKNetAddress* operator ->() { return &self; } + const LDKNetAddress* operator &() const { return &self; } + const LDKNetAddress* operator ->() const { return &self; } +}; +class UnsignedNodeAnnouncement { +private: + LDKUnsignedNodeAnnouncement self; +public: + UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete; + ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); } + UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); } + UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); } + operator LDKUnsignedNodeAnnouncement() { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; } + LDKUnsignedNodeAnnouncement* operator &() { return &self; } + LDKUnsignedNodeAnnouncement* operator ->() { return &self; } + const LDKUnsignedNodeAnnouncement* operator &() const { return &self; } + const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; } +}; +class NodeAnnouncement { +private: + LDKNodeAnnouncement self; +public: + NodeAnnouncement(const NodeAnnouncement&) = delete; + ~NodeAnnouncement() { NodeAnnouncement_free(self); } + NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); } + NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); } + operator LDKNodeAnnouncement() { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; } + LDKNodeAnnouncement* operator &() { return &self; } + LDKNodeAnnouncement* operator ->() { return &self; } + const LDKNodeAnnouncement* operator &() const { return &self; } + const LDKNodeAnnouncement* operator ->() const { return &self; } +}; +class UnsignedChannelAnnouncement { +private: + LDKUnsignedChannelAnnouncement self; +public: + UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete; + ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); } + UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); } + UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); } + operator LDKUnsignedChannelAnnouncement() { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; } + LDKUnsignedChannelAnnouncement* operator &() { return &self; } + LDKUnsignedChannelAnnouncement* operator ->() { return &self; } + const LDKUnsignedChannelAnnouncement* operator &() const { return &self; } + const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; } +}; +class ChannelAnnouncement { +private: + LDKChannelAnnouncement self; +public: + ChannelAnnouncement(const ChannelAnnouncement&) = delete; + ~ChannelAnnouncement() { ChannelAnnouncement_free(self); } + ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); } + ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); } + operator LDKChannelAnnouncement() { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; } + LDKChannelAnnouncement* operator &() { return &self; } + LDKChannelAnnouncement* operator ->() { return &self; } + const LDKChannelAnnouncement* operator &() const { return &self; } + const LDKChannelAnnouncement* operator ->() const { return &self; } +}; +class UnsignedChannelUpdate { +private: + LDKUnsignedChannelUpdate self; +public: + UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete; + ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); } + UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); } + UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); } + operator LDKUnsignedChannelUpdate() { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; } + LDKUnsignedChannelUpdate* operator &() { return &self; } + LDKUnsignedChannelUpdate* operator ->() { return &self; } + const LDKUnsignedChannelUpdate* operator &() const { return &self; } + const LDKUnsignedChannelUpdate* operator ->() const { return &self; } +}; +class ChannelUpdate { +private: + LDKChannelUpdate self; +public: + ChannelUpdate(const ChannelUpdate&) = delete; + ~ChannelUpdate() { ChannelUpdate_free(self); } + ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); } + ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); } + operator LDKChannelUpdate() { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; } + LDKChannelUpdate* operator &() { return &self; } + LDKChannelUpdate* operator ->() { return &self; } + const LDKChannelUpdate* operator &() const { return &self; } + const LDKChannelUpdate* operator ->() const { return &self; } +}; +class ErrorAction { +private: + LDKErrorAction self; +public: + ErrorAction(const ErrorAction&) = delete; + ~ErrorAction() { ErrorAction_free(self); } + ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); } + ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); } + operator LDKErrorAction() { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; } + LDKErrorAction* operator &() { return &self; } + LDKErrorAction* operator ->() { return &self; } + const LDKErrorAction* operator &() const { return &self; } + const LDKErrorAction* operator ->() const { return &self; } +}; +class LightningError { +private: + LDKLightningError self; +public: + LightningError(const LightningError&) = delete; + ~LightningError() { LightningError_free(self); } + LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); } + LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); } + operator LDKLightningError() { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; } + LDKLightningError* operator &() { return &self; } + LDKLightningError* operator ->() { return &self; } + const LDKLightningError* operator &() const { return &self; } + const LDKLightningError* operator ->() const { return &self; } +}; +class CommitmentUpdate { +private: + LDKCommitmentUpdate self; +public: + CommitmentUpdate(const CommitmentUpdate&) = delete; + ~CommitmentUpdate() { CommitmentUpdate_free(self); } + CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); } + CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); } + operator LDKCommitmentUpdate() { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; } + LDKCommitmentUpdate* operator &() { return &self; } + LDKCommitmentUpdate* operator ->() { return &self; } + const LDKCommitmentUpdate* operator &() const { return &self; } + const LDKCommitmentUpdate* operator ->() const { return &self; } +}; +class HTLCFailChannelUpdate { +private: + LDKHTLCFailChannelUpdate self; +public: + HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete; + ~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); } + HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); } + HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); } + operator LDKHTLCFailChannelUpdate() { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; } + LDKHTLCFailChannelUpdate* operator &() { return &self; } + LDKHTLCFailChannelUpdate* operator ->() { return &self; } + const LDKHTLCFailChannelUpdate* operator &() const { return &self; } + const LDKHTLCFailChannelUpdate* operator ->() const { return &self; } +}; +class ChannelMessageHandler { +private: + LDKChannelMessageHandler self; +public: + ChannelMessageHandler(const ChannelMessageHandler&) = delete; + ~ChannelMessageHandler() { ChannelMessageHandler_free(self); } + ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); } + ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); } + operator LDKChannelMessageHandler() { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; } + LDKChannelMessageHandler* operator &() { return &self; } + LDKChannelMessageHandler* operator ->() { return &self; } + const LDKChannelMessageHandler* operator &() const { return &self; } + const LDKChannelMessageHandler* operator ->() const { return &self; } +}; +class RoutingMessageHandler { +private: + LDKRoutingMessageHandler self; +public: + RoutingMessageHandler(const RoutingMessageHandler&) = delete; + ~RoutingMessageHandler() { RoutingMessageHandler_free(self); } + RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); } + RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); } + operator LDKRoutingMessageHandler() { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; } + LDKRoutingMessageHandler* operator &() { return &self; } + LDKRoutingMessageHandler* operator ->() { return &self; } + const LDKRoutingMessageHandler* operator &() const { return &self; } + const LDKRoutingMessageHandler* operator ->() const { return &self; } +}; +class MessageHandler { +private: + LDKMessageHandler self; +public: + MessageHandler(const MessageHandler&) = delete; + ~MessageHandler() { MessageHandler_free(self); } + MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); } + MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); } + operator LDKMessageHandler() { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; } + LDKMessageHandler* operator &() { return &self; } + LDKMessageHandler* operator ->() { return &self; } + const LDKMessageHandler* operator &() const { return &self; } + const LDKMessageHandler* operator ->() const { return &self; } +}; +class SocketDescriptor { +private: + LDKSocketDescriptor self; +public: + SocketDescriptor(const SocketDescriptor&) = delete; + ~SocketDescriptor() { SocketDescriptor_free(self); } + SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); } + SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); } + operator LDKSocketDescriptor() { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; } + LDKSocketDescriptor* operator &() { return &self; } + LDKSocketDescriptor* operator ->() { return &self; } + const LDKSocketDescriptor* operator &() const { return &self; } + const LDKSocketDescriptor* operator ->() const { return &self; } +}; +class PeerHandleError { +private: + LDKPeerHandleError self; +public: + PeerHandleError(const PeerHandleError&) = delete; + ~PeerHandleError() { PeerHandleError_free(self); } + PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); } + PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); } + operator LDKPeerHandleError() { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; } + LDKPeerHandleError* operator &() { return &self; } + LDKPeerHandleError* operator ->() { return &self; } + const LDKPeerHandleError* operator &() const { return &self; } + const LDKPeerHandleError* operator ->() const { return &self; } +}; +class PeerManager { +private: + LDKPeerManager self; +public: + PeerManager(const PeerManager&) = delete; + ~PeerManager() { PeerManager_free(self); } + PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); } + PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); } + operator LDKPeerManager() { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; } + LDKPeerManager* operator &() { return &self; } + LDKPeerManager* operator ->() { return &self; } + const LDKPeerManager* operator &() const { return &self; } + const LDKPeerManager* operator ->() const { return &self; } +}; +class TxCreationKeys { +private: + LDKTxCreationKeys self; +public: + TxCreationKeys(const TxCreationKeys&) = delete; + ~TxCreationKeys() { TxCreationKeys_free(self); } + TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); } + TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); } + operator LDKTxCreationKeys() { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; } + LDKTxCreationKeys* operator &() { return &self; } + LDKTxCreationKeys* operator ->() { return &self; } + const LDKTxCreationKeys* operator &() const { return &self; } + const LDKTxCreationKeys* operator ->() const { return &self; } +}; +class PreCalculatedTxCreationKeys { +private: + LDKPreCalculatedTxCreationKeys self; +public: + PreCalculatedTxCreationKeys(const PreCalculatedTxCreationKeys&) = delete; + ~PreCalculatedTxCreationKeys() { PreCalculatedTxCreationKeys_free(self); } + PreCalculatedTxCreationKeys(PreCalculatedTxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(PreCalculatedTxCreationKeys)); } + PreCalculatedTxCreationKeys(LDKPreCalculatedTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPreCalculatedTxCreationKeys)); } + operator LDKPreCalculatedTxCreationKeys() { LDKPreCalculatedTxCreationKeys res = self; memset(&self, 0, sizeof(LDKPreCalculatedTxCreationKeys)); return res; } + LDKPreCalculatedTxCreationKeys* operator &() { return &self; } + LDKPreCalculatedTxCreationKeys* operator ->() { return &self; } + const LDKPreCalculatedTxCreationKeys* operator &() const { return &self; } + const LDKPreCalculatedTxCreationKeys* operator ->() const { return &self; } +}; +class ChannelPublicKeys { +private: + LDKChannelPublicKeys self; +public: + ChannelPublicKeys(const ChannelPublicKeys&) = delete; + ~ChannelPublicKeys() { ChannelPublicKeys_free(self); } + ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); } + ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); } + operator LDKChannelPublicKeys() { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; } + LDKChannelPublicKeys* operator &() { return &self; } + LDKChannelPublicKeys* operator ->() { return &self; } + const LDKChannelPublicKeys* operator &() const { return &self; } + const LDKChannelPublicKeys* operator ->() const { return &self; } +}; +class HTLCOutputInCommitment { +private: + LDKHTLCOutputInCommitment self; +public: + HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete; + ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); } + HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); } + HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); } + operator LDKHTLCOutputInCommitment() { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; } + LDKHTLCOutputInCommitment* operator &() { return &self; } + LDKHTLCOutputInCommitment* operator ->() { return &self; } + const LDKHTLCOutputInCommitment* operator &() const { return &self; } + const LDKHTLCOutputInCommitment* operator ->() const { return &self; } +}; +class LocalCommitmentTransaction { +private: + LDKLocalCommitmentTransaction self; +public: + LocalCommitmentTransaction(const LocalCommitmentTransaction&) = delete; + ~LocalCommitmentTransaction() { LocalCommitmentTransaction_free(self); } + LocalCommitmentTransaction(LocalCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(LocalCommitmentTransaction)); } + LocalCommitmentTransaction(LDKLocalCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLocalCommitmentTransaction)); } + operator LDKLocalCommitmentTransaction() { LDKLocalCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKLocalCommitmentTransaction)); return res; } + LDKLocalCommitmentTransaction* operator &() { return &self; } + LDKLocalCommitmentTransaction* operator ->() { return &self; } + const LDKLocalCommitmentTransaction* operator &() const { return &self; } + const LDKLocalCommitmentTransaction* operator ->() const { return &self; } +}; +class InitFeatures { +private: + LDKInitFeatures self; +public: + InitFeatures(const InitFeatures&) = delete; + ~InitFeatures() { InitFeatures_free(self); } + InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); } + InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); } + operator LDKInitFeatures() { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; } + LDKInitFeatures* operator &() { return &self; } + LDKInitFeatures* operator ->() { return &self; } + const LDKInitFeatures* operator &() const { return &self; } + const LDKInitFeatures* operator ->() const { return &self; } +}; +class NodeFeatures { +private: + LDKNodeFeatures self; +public: + NodeFeatures(const NodeFeatures&) = delete; + ~NodeFeatures() { NodeFeatures_free(self); } + NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); } + NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); } + operator LDKNodeFeatures() { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; } + LDKNodeFeatures* operator &() { return &self; } + LDKNodeFeatures* operator ->() { return &self; } + const LDKNodeFeatures* operator &() const { return &self; } + const LDKNodeFeatures* operator ->() const { return &self; } +}; +class ChannelFeatures { +private: + LDKChannelFeatures self; +public: + ChannelFeatures(const ChannelFeatures&) = delete; + ~ChannelFeatures() { ChannelFeatures_free(self); } + ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); } + ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); } + operator LDKChannelFeatures() { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; } + LDKChannelFeatures* operator &() { return &self; } + LDKChannelFeatures* operator ->() { return &self; } + const LDKChannelFeatures* operator &() const { return &self; } + const LDKChannelFeatures* operator ->() const { return &self; } +}; +class RouteHop { +private: + LDKRouteHop self; +public: + RouteHop(const RouteHop&) = delete; + ~RouteHop() { RouteHop_free(self); } + RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); } + RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); } + operator LDKRouteHop() { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; } + LDKRouteHop* operator &() { return &self; } + LDKRouteHop* operator ->() { return &self; } + const LDKRouteHop* operator &() const { return &self; } + const LDKRouteHop* operator ->() const { return &self; } +}; +class Route { +private: + LDKRoute self; +public: + Route(const Route&) = delete; + ~Route() { Route_free(self); } + Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); } + Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); } + operator LDKRoute() { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; } + LDKRoute* operator &() { return &self; } + LDKRoute* operator ->() { return &self; } + const LDKRoute* operator &() const { return &self; } + const LDKRoute* operator ->() const { return &self; } +}; +class RouteHint { +private: + LDKRouteHint self; +public: + RouteHint(const RouteHint&) = delete; + ~RouteHint() { RouteHint_free(self); } + RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); } + RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); } + operator LDKRouteHint() { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; } + LDKRouteHint* operator &() { return &self; } + LDKRouteHint* operator ->() { return &self; } + const LDKRouteHint* operator &() const { return &self; } + const LDKRouteHint* operator ->() const { return &self; } +}; +class NetworkGraph { +private: + LDKNetworkGraph self; +public: + NetworkGraph(const NetworkGraph&) = delete; + ~NetworkGraph() { NetworkGraph_free(self); } + NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); } + NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); } + operator LDKNetworkGraph() { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; } + LDKNetworkGraph* operator &() { return &self; } + LDKNetworkGraph* operator ->() { return &self; } + const LDKNetworkGraph* operator &() const { return &self; } + const LDKNetworkGraph* operator ->() const { return &self; } +}; +class LockedNetworkGraph { +private: + LDKLockedNetworkGraph self; +public: + LockedNetworkGraph(const LockedNetworkGraph&) = delete; + ~LockedNetworkGraph() { LockedNetworkGraph_free(self); } + LockedNetworkGraph(LockedNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(LockedNetworkGraph)); } + LockedNetworkGraph(LDKLockedNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedNetworkGraph)); } + operator LDKLockedNetworkGraph() { LDKLockedNetworkGraph res = self; memset(&self, 0, sizeof(LDKLockedNetworkGraph)); return res; } + LDKLockedNetworkGraph* operator &() { return &self; } + LDKLockedNetworkGraph* operator ->() { return &self; } + const LDKLockedNetworkGraph* operator &() const { return &self; } + const LDKLockedNetworkGraph* operator ->() const { return &self; } +}; +class NetGraphMsgHandler { +private: + LDKNetGraphMsgHandler self; +public: + NetGraphMsgHandler(const NetGraphMsgHandler&) = delete; + ~NetGraphMsgHandler() { NetGraphMsgHandler_free(self); } + NetGraphMsgHandler(NetGraphMsgHandler&& o) : self(o.self) { memset(&o, 0, sizeof(NetGraphMsgHandler)); } + NetGraphMsgHandler(LDKNetGraphMsgHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetGraphMsgHandler)); } + operator LDKNetGraphMsgHandler() { LDKNetGraphMsgHandler res = self; memset(&self, 0, sizeof(LDKNetGraphMsgHandler)); return res; } + LDKNetGraphMsgHandler* operator &() { return &self; } + LDKNetGraphMsgHandler* operator ->() { return &self; } + const LDKNetGraphMsgHandler* operator &() const { return &self; } + const LDKNetGraphMsgHandler* operator ->() const { return &self; } +}; +class DirectionalChannelInfo { +private: + LDKDirectionalChannelInfo self; +public: + DirectionalChannelInfo(const DirectionalChannelInfo&) = delete; + ~DirectionalChannelInfo() { DirectionalChannelInfo_free(self); } + DirectionalChannelInfo(DirectionalChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectionalChannelInfo)); } + DirectionalChannelInfo(LDKDirectionalChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectionalChannelInfo)); } + operator LDKDirectionalChannelInfo() { LDKDirectionalChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectionalChannelInfo)); return res; } + LDKDirectionalChannelInfo* operator &() { return &self; } + LDKDirectionalChannelInfo* operator ->() { return &self; } + const LDKDirectionalChannelInfo* operator &() const { return &self; } + const LDKDirectionalChannelInfo* operator ->() const { return &self; } +}; +class ChannelInfo { +private: + LDKChannelInfo self; +public: + ChannelInfo(const ChannelInfo&) = delete; + ~ChannelInfo() { ChannelInfo_free(self); } + ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); } + ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); } + operator LDKChannelInfo() { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; } + LDKChannelInfo* operator &() { return &self; } + LDKChannelInfo* operator ->() { return &self; } + const LDKChannelInfo* operator &() const { return &self; } + const LDKChannelInfo* operator ->() const { return &self; } +}; +class RoutingFees { +private: + LDKRoutingFees self; +public: + RoutingFees(const RoutingFees&) = delete; + ~RoutingFees() { RoutingFees_free(self); } + RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); } + RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); } + operator LDKRoutingFees() { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; } + LDKRoutingFees* operator &() { return &self; } + LDKRoutingFees* operator ->() { return &self; } + const LDKRoutingFees* operator &() const { return &self; } + const LDKRoutingFees* operator ->() const { return &self; } +}; +class NodeAnnouncementInfo { +private: + LDKNodeAnnouncementInfo self; +public: + NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete; + ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); } + NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); } + NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); } + operator LDKNodeAnnouncementInfo() { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; } + LDKNodeAnnouncementInfo* operator &() { return &self; } + LDKNodeAnnouncementInfo* operator ->() { return &self; } + const LDKNodeAnnouncementInfo* operator &() const { return &self; } + const LDKNodeAnnouncementInfo* operator ->() const { return &self; } +}; +class NodeInfo { +private: + LDKNodeInfo self; +public: + NodeInfo(const NodeInfo&) = delete; + ~NodeInfo() { NodeInfo_free(self); } + NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); } + NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); } + operator LDKNodeInfo() { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; } + LDKNodeInfo* operator &() { return &self; } + LDKNodeInfo* operator ->() { return &self; } + const LDKNodeInfo* operator &() const { return &self; } + const LDKNodeInfo* operator ->() const { return &self; } +}; +class CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ { +private: + LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ self; +public: + CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(const CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&) = delete; + ~CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ() { CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ_free(self); } + CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); } + CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); } + operator LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ() { LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); return res; } + LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator &() { return &self; } + LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator ->() { return &self; } + const LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator &() const { return &self; } + const LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator ->() const { return &self; } +}; +class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ { +private: + LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self; +public: + CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete; + ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); } + CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); } + CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); } + operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; } + LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; } + LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; } + const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; } + const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; } +}; +class CVec_CVec_RouteHopZZ { +private: + LDKCVec_CVec_RouteHopZZ self; +public: + CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete; + ~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); } + CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); } + CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); } + operator LDKCVec_CVec_RouteHopZZ() { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; } + LDKCVec_CVec_RouteHopZZ* operator &() { return &self; } + LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; } + const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; } + const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; } +}; +class CVec_HTLCOutputInCommitmentZ { +private: + LDKCVec_HTLCOutputInCommitmentZ self; +public: + CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete; + ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); } + CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); } + CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); } + operator LDKCVec_HTLCOutputInCommitmentZ() { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; } + LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; } + LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; } + const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; } + const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; } +}; +class CResult_NoneMonitorUpdateErrorZ { +private: + LDKCResult_NoneMonitorUpdateErrorZ self; +public: + CResult_NoneMonitorUpdateErrorZ(const CResult_NoneMonitorUpdateErrorZ&) = delete; + ~CResult_NoneMonitorUpdateErrorZ() { CResult_NoneMonitorUpdateErrorZ_free(self); } + CResult_NoneMonitorUpdateErrorZ(CResult_NoneMonitorUpdateErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); } + CResult_NoneMonitorUpdateErrorZ(LDKCResult_NoneMonitorUpdateErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); } + operator LDKCResult_NoneMonitorUpdateErrorZ() { LDKCResult_NoneMonitorUpdateErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); return res; } + LDKCResult_NoneMonitorUpdateErrorZ* operator &() { return &self; } + LDKCResult_NoneMonitorUpdateErrorZ* operator ->() { return &self; } + const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; } + const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; } +}; +class C2Tuple_Txidu32Z { +private: + LDKC2Tuple_Txidu32Z self; +public: + C2Tuple_Txidu32Z(const C2Tuple_Txidu32Z&) = delete; + ~C2Tuple_Txidu32Z() { C2Tuple_Txidu32Z_free(self); } + C2Tuple_Txidu32Z(C2Tuple_Txidu32Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Txidu32Z)); } + C2Tuple_Txidu32Z(LDKC2Tuple_Txidu32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Txidu32Z)); } + operator LDKC2Tuple_Txidu32Z() { LDKC2Tuple_Txidu32Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Txidu32Z)); return res; } + LDKC2Tuple_Txidu32Z* operator &() { return &self; } + LDKC2Tuple_Txidu32Z* operator ->() { return &self; } + const LDKC2Tuple_Txidu32Z* operator &() const { return &self; } + const LDKC2Tuple_Txidu32Z* operator ->() const { return &self; } +}; +class CResult_SignatureNoneZ { +private: + LDKCResult_SignatureNoneZ self; +public: + CResult_SignatureNoneZ(const CResult_SignatureNoneZ&) = delete; + ~CResult_SignatureNoneZ() { CResult_SignatureNoneZ_free(self); } + CResult_SignatureNoneZ(CResult_SignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignatureNoneZ)); } + CResult_SignatureNoneZ(LDKCResult_SignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignatureNoneZ)); } + operator LDKCResult_SignatureNoneZ() { LDKCResult_SignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignatureNoneZ)); return res; } + LDKCResult_SignatureNoneZ* operator &() { return &self; } + LDKCResult_SignatureNoneZ* operator ->() { return &self; } + const LDKCResult_SignatureNoneZ* operator &() const { return &self; } + const LDKCResult_SignatureNoneZ* operator ->() const { return &self; } +}; +class CVec_UpdateFailMalformedHTLCZ { +private: + LDKCVec_UpdateFailMalformedHTLCZ self; +public: + CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete; + ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); } + CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); } + CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); } + operator LDKCVec_UpdateFailMalformedHTLCZ() { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; } + LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; } + LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; } + const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; } + const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; } +}; +class CResult_NoneAPIErrorZ { +private: + LDKCResult_NoneAPIErrorZ self; +public: + CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete; + ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); } + CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); } + CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); } + operator LDKCResult_NoneAPIErrorZ() { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; } + LDKCResult_NoneAPIErrorZ* operator &() { return &self; } + LDKCResult_NoneAPIErrorZ* operator ->() { return &self; } + const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; } + const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; } +}; +class CVec_SpendableOutputDescriptorZ { +private: + LDKCVec_SpendableOutputDescriptorZ self; +public: + CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete; + ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); } + CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); } + CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); } + operator LDKCVec_SpendableOutputDescriptorZ() { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; } + LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; } + LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; } + const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; } + const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; } +}; +class C2Tuple_SignatureCVec_SignatureZZ { +private: + LDKC2Tuple_SignatureCVec_SignatureZZ self; +public: + C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete; + ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); } + C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); } + C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); } + operator LDKC2Tuple_SignatureCVec_SignatureZZ() { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; } + LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; } + LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; } + const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; } + const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; } +}; +class CResult_CVec_SignatureZNoneZ { +private: + LDKCResult_CVec_SignatureZNoneZ self; +public: + CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete; + ~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); } + CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); } + CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); } + operator LDKCResult_CVec_SignatureZNoneZ() { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; } + LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; } + LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; } + const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; } + const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; } +}; +class CResult_CVec_u8ZPeerHandleErrorZ { +private: + LDKCResult_CVec_u8ZPeerHandleErrorZ self; +public: + CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete; + ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); } + CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); } + CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); } + operator LDKCResult_CVec_u8ZPeerHandleErrorZ() { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; } + LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; } + LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; } + const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; } + const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; } +}; +class CResult_TxCreationKeysSecpErrorZ { +private: + LDKCResult_TxCreationKeysSecpErrorZ self; +public: + CResult_TxCreationKeysSecpErrorZ(const CResult_TxCreationKeysSecpErrorZ&) = delete; + ~CResult_TxCreationKeysSecpErrorZ() { CResult_TxCreationKeysSecpErrorZ_free(self); } + CResult_TxCreationKeysSecpErrorZ(CResult_TxCreationKeysSecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysSecpErrorZ)); } + CResult_TxCreationKeysSecpErrorZ(LDKCResult_TxCreationKeysSecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); } + operator LDKCResult_TxCreationKeysSecpErrorZ() { LDKCResult_TxCreationKeysSecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); return res; } + LDKCResult_TxCreationKeysSecpErrorZ* operator &() { return &self; } + LDKCResult_TxCreationKeysSecpErrorZ* operator ->() { return &self; } + const LDKCResult_TxCreationKeysSecpErrorZ* operator &() const { return &self; } + const LDKCResult_TxCreationKeysSecpErrorZ* operator ->() const { return &self; } +}; +class CVec_RouteHopZ { +private: + LDKCVec_RouteHopZ self; +public: + CVec_RouteHopZ(const CVec_RouteHopZ&) = delete; + ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); } + CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); } + CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); } + operator LDKCVec_RouteHopZ() { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; } + LDKCVec_RouteHopZ* operator &() { return &self; } + LDKCVec_RouteHopZ* operator ->() { return &self; } + const LDKCVec_RouteHopZ* operator &() const { return &self; } + const LDKCVec_RouteHopZ* operator ->() const { return &self; } +}; +class CVec_RouteHintZ { +private: + LDKCVec_RouteHintZ self; +public: + CVec_RouteHintZ(const CVec_RouteHintZ&) = delete; + ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); } + CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); } + CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); } + operator LDKCVec_RouteHintZ() { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; } + LDKCVec_RouteHintZ* operator &() { return &self; } + LDKCVec_RouteHintZ* operator ->() { return &self; } + const LDKCVec_RouteHintZ* operator &() const { return &self; } + const LDKCVec_RouteHintZ* operator ->() const { return &self; } +}; +class CResult_RouteLightningErrorZ { +private: + LDKCResult_RouteLightningErrorZ self; +public: + CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete; + ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); } + CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); } + CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); } + operator LDKCResult_RouteLightningErrorZ() { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; } + LDKCResult_RouteLightningErrorZ* operator &() { return &self; } + LDKCResult_RouteLightningErrorZ* operator ->() { return &self; } + const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; } + const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; } +}; +class C2Tuple_u64u64Z { +private: + LDKC2Tuple_u64u64Z self; +public: + C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete; + ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); } + C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); } + C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); } + operator LDKC2Tuple_u64u64Z() { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; } + LDKC2Tuple_u64u64Z* operator &() { return &self; } + LDKC2Tuple_u64u64Z* operator ->() { return &self; } + const LDKC2Tuple_u64u64Z* operator &() const { return &self; } + const LDKC2Tuple_u64u64Z* operator ->() const { return &self; } +}; +class CVec_MessageSendEventZ { +private: + LDKCVec_MessageSendEventZ self; +public: + CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete; + ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); } + CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); } + CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); } + operator LDKCVec_MessageSendEventZ() { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; } + LDKCVec_MessageSendEventZ* operator &() { return &self; } + LDKCVec_MessageSendEventZ* operator ->() { return &self; } + const LDKCVec_MessageSendEventZ* operator &() const { return &self; } + const LDKCVec_MessageSendEventZ* operator ->() const { return &self; } +}; +class C2Tuple_HTLCOutputInCommitmentSignatureZ { +private: + LDKC2Tuple_HTLCOutputInCommitmentSignatureZ self; +public: + C2Tuple_HTLCOutputInCommitmentSignatureZ(const C2Tuple_HTLCOutputInCommitmentSignatureZ&) = delete; + ~C2Tuple_HTLCOutputInCommitmentSignatureZ() { C2Tuple_HTLCOutputInCommitmentSignatureZ_free(self); } + C2Tuple_HTLCOutputInCommitmentSignatureZ(C2Tuple_HTLCOutputInCommitmentSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_HTLCOutputInCommitmentSignatureZ)); } + C2Tuple_HTLCOutputInCommitmentSignatureZ(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ)); } + operator LDKC2Tuple_HTLCOutputInCommitmentSignatureZ() { LDKC2Tuple_HTLCOutputInCommitmentSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ)); return res; } + LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator &() { return &self; } + LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator ->() { return &self; } + const LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator &() const { return &self; } + const LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator ->() const { return &self; } +}; +class CVec_SignatureZ { +private: + LDKCVec_SignatureZ self; +public: + CVec_SignatureZ(const CVec_SignatureZ&) = delete; + ~CVec_SignatureZ() { CVec_SignatureZ_free(self); } + CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); } + CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); } + operator LDKCVec_SignatureZ() { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; } + LDKCVec_SignatureZ* operator &() { return &self; } + LDKCVec_SignatureZ* operator ->() { return &self; } + const LDKCVec_SignatureZ* operator &() const { return &self; } + const LDKCVec_SignatureZ* operator ->() const { return &self; } +}; +class CVec_usizeZ { +private: + LDKCVec_usizeZ self; +public: + CVec_usizeZ(const CVec_usizeZ&) = delete; + ~CVec_usizeZ() { CVec_usizeZ_free(self); } + CVec_usizeZ(CVec_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_usizeZ)); } + CVec_usizeZ(LDKCVec_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_usizeZ)); } + operator LDKCVec_usizeZ() { LDKCVec_usizeZ res = self; memset(&self, 0, sizeof(LDKCVec_usizeZ)); return res; } + LDKCVec_usizeZ* operator &() { return &self; } + LDKCVec_usizeZ* operator ->() { return &self; } + const LDKCVec_usizeZ* operator &() const { return &self; } + const LDKCVec_usizeZ* operator ->() const { return &self; } +}; +class C2Tuple_Scriptu64Z { +private: + LDKC2Tuple_Scriptu64Z self; +public: + C2Tuple_Scriptu64Z(const C2Tuple_Scriptu64Z&) = delete; + ~C2Tuple_Scriptu64Z() { C2Tuple_Scriptu64Z_free(self); } + C2Tuple_Scriptu64Z(C2Tuple_Scriptu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Scriptu64Z)); } + C2Tuple_Scriptu64Z(LDKC2Tuple_Scriptu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Scriptu64Z)); } + operator LDKC2Tuple_Scriptu64Z() { LDKC2Tuple_Scriptu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Scriptu64Z)); return res; } + LDKC2Tuple_Scriptu64Z* operator &() { return &self; } + LDKC2Tuple_Scriptu64Z* operator ->() { return &self; } + const LDKC2Tuple_Scriptu64Z* operator &() const { return &self; } + const LDKC2Tuple_Scriptu64Z* operator ->() const { return &self; } +}; +class CResult_NoneChannelMonitorUpdateErrZ { +private: + LDKCResult_NoneChannelMonitorUpdateErrZ self; +public: + CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete; + ~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); } + CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); } + CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); } + operator LDKCResult_NoneChannelMonitorUpdateErrZ() { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; } + LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; } + LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; } + const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; } + const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; } +}; +class CVec_u64Z { +private: + LDKCVec_u64Z self; +public: + CVec_u64Z(const CVec_u64Z&) = delete; + ~CVec_u64Z() { CVec_u64Z_free(self); } + CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); } + CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); } + operator LDKCVec_u64Z() { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; } + LDKCVec_u64Z* operator &() { return &self; } + LDKCVec_u64Z* operator ->() { return &self; } + const LDKCVec_u64Z* operator &() const { return &self; } + const LDKCVec_u64Z* operator ->() const { return &self; } +}; +class C2Tuple_OutPointScriptZ { +private: + LDKC2Tuple_OutPointScriptZ self; +public: + C2Tuple_OutPointScriptZ(const C2Tuple_OutPointScriptZ&) = delete; + ~C2Tuple_OutPointScriptZ() { C2Tuple_OutPointScriptZ_free(self); } + C2Tuple_OutPointScriptZ(C2Tuple_OutPointScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); } + C2Tuple_OutPointScriptZ(LDKC2Tuple_OutPointScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); } + operator LDKC2Tuple_OutPointScriptZ() { LDKC2Tuple_OutPointScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); return res; } + LDKC2Tuple_OutPointScriptZ* operator &() { return &self; } + LDKC2Tuple_OutPointScriptZ* operator ->() { return &self; } + const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; } + const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; } +}; +class CVec_ChannelMonitorZ { +private: + LDKCVec_ChannelMonitorZ self; +public: + CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete; + ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); } + CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); } + CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); } + operator LDKCVec_ChannelMonitorZ() { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; } + LDKCVec_ChannelMonitorZ* operator &() { return &self; } + LDKCVec_ChannelMonitorZ* operator ->() { return &self; } + const LDKCVec_ChannelMonitorZ* operator &() const { return &self; } + const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; } +}; +class CVec_UpdateFulfillHTLCZ { +private: + LDKCVec_UpdateFulfillHTLCZ self; +public: + CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete; + ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); } + CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); } + CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); } + operator LDKCVec_UpdateFulfillHTLCZ() { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; } + LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; } + LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; } + const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; } + const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; } +}; +class CResult_C2Tuple_Scriptu64ZChainErrorZ { +private: + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ self; +public: + CResult_C2Tuple_Scriptu64ZChainErrorZ(const CResult_C2Tuple_Scriptu64ZChainErrorZ&) = delete; + ~CResult_C2Tuple_Scriptu64ZChainErrorZ() { CResult_C2Tuple_Scriptu64ZChainErrorZ_free(self); } + CResult_C2Tuple_Scriptu64ZChainErrorZ(CResult_C2Tuple_Scriptu64ZChainErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_Scriptu64ZChainErrorZ)); } + CResult_C2Tuple_Scriptu64ZChainErrorZ(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); } + operator LDKCResult_C2Tuple_Scriptu64ZChainErrorZ() { LDKCResult_C2Tuple_Scriptu64ZChainErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); return res; } + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator &() { return &self; } + LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator ->() { return &self; } + const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator &() const { return &self; } + const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator ->() const { return &self; } +}; +class CVec_ChannelDetailsZ { +private: + LDKCVec_ChannelDetailsZ self; +public: + CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete; + ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); } + CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); } + CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); } + operator LDKCVec_ChannelDetailsZ() { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; } + LDKCVec_ChannelDetailsZ* operator &() { return &self; } + LDKCVec_ChannelDetailsZ* operator ->() { return &self; } + const LDKCVec_ChannelDetailsZ* operator &() const { return &self; } + const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; } +}; +class CResult_boolLightningErrorZ { +private: + LDKCResult_boolLightningErrorZ self; +public: + CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete; + ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); } + CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); } + CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); } + operator LDKCResult_boolLightningErrorZ() { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; } + LDKCResult_boolLightningErrorZ* operator &() { return &self; } + LDKCResult_boolLightningErrorZ* operator ->() { return &self; } + const LDKCResult_boolLightningErrorZ* operator &() const { return &self; } + const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; } +}; +class CVec_NetAddressZ { +private: + LDKCVec_NetAddressZ self; +public: + CVec_NetAddressZ(const CVec_NetAddressZ&) = delete; + ~CVec_NetAddressZ() { CVec_NetAddressZ_free(self); } + CVec_NetAddressZ(CVec_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NetAddressZ)); } + CVec_NetAddressZ(LDKCVec_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NetAddressZ)); } + operator LDKCVec_NetAddressZ() { LDKCVec_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_NetAddressZ)); return res; } + LDKCVec_NetAddressZ* operator &() { return &self; } + LDKCVec_NetAddressZ* operator ->() { return &self; } + const LDKCVec_NetAddressZ* operator &() const { return &self; } + const LDKCVec_NetAddressZ* operator ->() const { return &self; } +}; +class CVec_UpdateFailHTLCZ { +private: + LDKCVec_UpdateFailHTLCZ self; +public: + CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete; + ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); } + CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); } + CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); } + operator LDKCVec_UpdateFailHTLCZ() { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; } + LDKCVec_UpdateFailHTLCZ* operator &() { return &self; } + LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; } + const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; } + const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; } +}; +class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { +private: + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self; +public: + C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete; + ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); } + C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); } + C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); } + operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; } + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; } + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; } + const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; } + const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; } +}; +class CVec_MonitorEventZ { +private: + LDKCVec_MonitorEventZ self; +public: + CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete; + ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); } + CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); } + CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); } + operator LDKCVec_MonitorEventZ() { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; } + LDKCVec_MonitorEventZ* operator &() { return &self; } + LDKCVec_MonitorEventZ* operator ->() { return &self; } + const LDKCVec_MonitorEventZ* operator &() const { return &self; } + const LDKCVec_MonitorEventZ* operator ->() const { return &self; } +}; +class CVec_UpdateAddHTLCZ { +private: + LDKCVec_UpdateAddHTLCZ self; +public: + CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete; + ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); } + CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); } + CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); } + operator LDKCVec_UpdateAddHTLCZ() { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; } + LDKCVec_UpdateAddHTLCZ* operator &() { return &self; } + LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; } + const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; } + const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; } +}; +class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { +private: + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self; +public: + CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete; + ~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); } + CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); } + CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); } + operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; } + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; } + LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; } + const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; } + const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; } +}; +class CVec_PublicKeyZ { +private: + LDKCVec_PublicKeyZ self; +public: + CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete; + ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); } + CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); } + CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); } + operator LDKCVec_PublicKeyZ() { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; } + LDKCVec_PublicKeyZ* operator &() { return &self; } + LDKCVec_PublicKeyZ* operator ->() { return &self; } + const LDKCVec_PublicKeyZ* operator &() const { return &self; } + const LDKCVec_PublicKeyZ* operator ->() const { return &self; } +}; +class CResult_NonePeerHandleErrorZ { +private: + LDKCResult_NonePeerHandleErrorZ self; +public: + CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete; + ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); } + CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); } + CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); } + operator LDKCResult_NonePeerHandleErrorZ() { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; } + LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; } + LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; } + const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; } + const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; } +}; +class CVec_NodeAnnouncementZ { +private: + LDKCVec_NodeAnnouncementZ self; +public: + CVec_NodeAnnouncementZ(const CVec_NodeAnnouncementZ&) = delete; + ~CVec_NodeAnnouncementZ() { CVec_NodeAnnouncementZ_free(self); } + CVec_NodeAnnouncementZ(CVec_NodeAnnouncementZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); } + CVec_NodeAnnouncementZ(LDKCVec_NodeAnnouncementZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); } + operator LDKCVec_NodeAnnouncementZ() { LDKCVec_NodeAnnouncementZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); return res; } + LDKCVec_NodeAnnouncementZ* operator &() { return &self; } + LDKCVec_NodeAnnouncementZ* operator ->() { return &self; } + const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; } + const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; } +}; +class CResult_boolPeerHandleErrorZ { +private: + LDKCResult_boolPeerHandleErrorZ self; +public: + CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete; + ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); } + CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); } + CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); } + operator LDKCResult_boolPeerHandleErrorZ() { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; } + LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; } + LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; } + const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; } + const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; } +}; +class CResult_SecretKeySecpErrorZ { +private: + LDKCResult_SecretKeySecpErrorZ self; +public: + CResult_SecretKeySecpErrorZ(const CResult_SecretKeySecpErrorZ&) = delete; + ~CResult_SecretKeySecpErrorZ() { CResult_SecretKeySecpErrorZ_free(self); } + CResult_SecretKeySecpErrorZ(CResult_SecretKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeySecpErrorZ)); } + CResult_SecretKeySecpErrorZ(LDKCResult_SecretKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); } + operator LDKCResult_SecretKeySecpErrorZ() { LDKCResult_SecretKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); return res; } + LDKCResult_SecretKeySecpErrorZ* operator &() { return &self; } + LDKCResult_SecretKeySecpErrorZ* operator ->() { return &self; } + const LDKCResult_SecretKeySecpErrorZ* operator &() const { return &self; } + const LDKCResult_SecretKeySecpErrorZ* operator ->() const { return &self; } +}; +class CVec_TransactionZ { +private: + LDKCVec_TransactionZ self; +public: + CVec_TransactionZ(const CVec_TransactionZ&) = delete; + ~CVec_TransactionZ() { CVec_TransactionZ_free(self); } + CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); } + CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); } + operator LDKCVec_TransactionZ() { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; } + LDKCVec_TransactionZ* operator &() { return &self; } + LDKCVec_TransactionZ* operator ->() { return &self; } + const LDKCVec_TransactionZ* operator &() const { return &self; } + const LDKCVec_TransactionZ* operator ->() const { return &self; } +}; +class CResult_NonePaymentSendFailureZ { +private: + LDKCResult_NonePaymentSendFailureZ self; +public: + CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete; + ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); } + CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); } + CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); } + operator LDKCResult_NonePaymentSendFailureZ() { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; } + LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; } + LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; } + const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; } + const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; } +}; +class CVec_EventZ { +private: + LDKCVec_EventZ self; +public: + CVec_EventZ(const CVec_EventZ&) = delete; + ~CVec_EventZ() { CVec_EventZ_free(self); } + CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); } + CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); } + operator LDKCVec_EventZ() { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; } + LDKCVec_EventZ* operator &() { return &self; } + LDKCVec_EventZ* operator ->() { return &self; } + const LDKCVec_EventZ* operator &() const { return &self; } + const LDKCVec_EventZ* operator ->() const { return &self; } +}; +class CVec_u8Z { +private: + LDKCVec_u8Z self; +public: + CVec_u8Z(const CVec_u8Z&) = delete; + ~CVec_u8Z() { CVec_u8Z_free(self); } + CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); } + CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); } + operator LDKCVec_u8Z() { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; } + LDKCVec_u8Z* operator &() { return &self; } + LDKCVec_u8Z* operator ->() { return &self; } + const LDKCVec_u8Z* operator &() const { return &self; } + const LDKCVec_u8Z* operator ->() const { return &self; } +}; +class CResult_PublicKeySecpErrorZ { +private: + LDKCResult_PublicKeySecpErrorZ self; +public: + CResult_PublicKeySecpErrorZ(const CResult_PublicKeySecpErrorZ&) = delete; + ~CResult_PublicKeySecpErrorZ() { CResult_PublicKeySecpErrorZ_free(self); } + CResult_PublicKeySecpErrorZ(CResult_PublicKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecpErrorZ)); } + CResult_PublicKeySecpErrorZ(LDKCResult_PublicKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); } + operator LDKCResult_PublicKeySecpErrorZ() { LDKCResult_PublicKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); return res; } + LDKCResult_PublicKeySecpErrorZ* operator &() { return &self; } + LDKCResult_PublicKeySecpErrorZ* operator ->() { return &self; } + const LDKCResult_PublicKeySecpErrorZ* operator &() const { return &self; } + const LDKCResult_PublicKeySecpErrorZ* operator ->() const { return &self; } +}; +} diff --git a/lightning-c-bindings/include/rust_types.h b/lightning-c-bindings/include/rust_types.h new file mode 100644 index 000000000..3b6821aa6 --- /dev/null +++ b/lightning-c-bindings/include/rust_types.h @@ -0,0 +1,154 @@ +#if defined(__GNUC__) +#define MUST_USE_STRUCT __attribute__((warn_unused)) +#else +#define MUST_USE_STRUCT +#endif +#if defined(__GNUC__) +#define MUST_USE_RES __attribute__((warn_unused_result)) +#else +#define MUST_USE_RES +#endif +struct nativeChannelHandshakeConfigOpaque; +typedef struct nativeChannelHandshakeConfigOpaque LDKnativeChannelHandshakeConfig; +struct nativeChannelHandshakeLimitsOpaque; +typedef struct nativeChannelHandshakeLimitsOpaque LDKnativeChannelHandshakeLimits; +struct nativeChannelConfigOpaque; +typedef struct nativeChannelConfigOpaque LDKnativeChannelConfig; +struct nativeUserConfigOpaque; +typedef struct nativeUserConfigOpaque LDKnativeUserConfig; +struct nativeChainWatchedUtilOpaque; +typedef struct nativeChainWatchedUtilOpaque LDKnativeChainWatchedUtil; +struct nativeBlockNotifierOpaque; +typedef struct nativeBlockNotifierOpaque LDKnativeBlockNotifier; +struct nativeChainWatchInterfaceUtilOpaque; +typedef struct nativeChainWatchInterfaceUtilOpaque LDKnativeChainWatchInterfaceUtil; +struct nativeOutPointOpaque; +typedef struct nativeOutPointOpaque LDKnativeOutPoint; +struct LDKChannelKeys; +typedef struct LDKChannelKeys LDKChannelKeys; +struct nativeInMemoryChannelKeysOpaque; +typedef struct nativeInMemoryChannelKeysOpaque LDKnativeInMemoryChannelKeys; +struct nativeKeysManagerOpaque; +typedef struct nativeKeysManagerOpaque LDKnativeKeysManager; +struct nativeChannelManagerOpaque; +typedef struct nativeChannelManagerOpaque LDKnativeChannelManager; +struct nativeChannelDetailsOpaque; +typedef struct nativeChannelDetailsOpaque LDKnativeChannelDetails; +struct nativePaymentSendFailureOpaque; +typedef struct nativePaymentSendFailureOpaque LDKnativePaymentSendFailure; +struct nativeChannelManagerReadArgsOpaque; +typedef struct nativeChannelManagerReadArgsOpaque LDKnativeChannelManagerReadArgs; +struct nativeChannelMonitorUpdateOpaque; +typedef struct nativeChannelMonitorUpdateOpaque LDKnativeChannelMonitorUpdate; +struct nativeMonitorUpdateErrorOpaque; +typedef struct nativeMonitorUpdateErrorOpaque LDKnativeMonitorUpdateError; +struct nativeMonitorEventOpaque; +typedef struct nativeMonitorEventOpaque LDKnativeMonitorEvent; +struct nativeHTLCUpdateOpaque; +typedef struct nativeHTLCUpdateOpaque LDKnativeHTLCUpdate; +struct nativeChannelMonitorOpaque; +typedef struct nativeChannelMonitorOpaque LDKnativeChannelMonitor; +struct nativeDecodeErrorOpaque; +typedef struct nativeDecodeErrorOpaque LDKnativeDecodeError; +struct nativeInitOpaque; +typedef struct nativeInitOpaque LDKnativeInit; +struct nativeErrorMessageOpaque; +typedef struct nativeErrorMessageOpaque LDKnativeErrorMessage; +struct nativePingOpaque; +typedef struct nativePingOpaque LDKnativePing; +struct nativePongOpaque; +typedef struct nativePongOpaque LDKnativePong; +struct nativeOpenChannelOpaque; +typedef struct nativeOpenChannelOpaque LDKnativeOpenChannel; +struct nativeAcceptChannelOpaque; +typedef struct nativeAcceptChannelOpaque LDKnativeAcceptChannel; +struct nativeFundingCreatedOpaque; +typedef struct nativeFundingCreatedOpaque LDKnativeFundingCreated; +struct nativeFundingSignedOpaque; +typedef struct nativeFundingSignedOpaque LDKnativeFundingSigned; +struct nativeFundingLockedOpaque; +typedef struct nativeFundingLockedOpaque LDKnativeFundingLocked; +struct nativeShutdownOpaque; +typedef struct nativeShutdownOpaque LDKnativeShutdown; +struct nativeClosingSignedOpaque; +typedef struct nativeClosingSignedOpaque LDKnativeClosingSigned; +struct nativeUpdateAddHTLCOpaque; +typedef struct nativeUpdateAddHTLCOpaque LDKnativeUpdateAddHTLC; +struct nativeUpdateFulfillHTLCOpaque; +typedef struct nativeUpdateFulfillHTLCOpaque LDKnativeUpdateFulfillHTLC; +struct nativeUpdateFailHTLCOpaque; +typedef struct nativeUpdateFailHTLCOpaque LDKnativeUpdateFailHTLC; +struct nativeUpdateFailMalformedHTLCOpaque; +typedef struct nativeUpdateFailMalformedHTLCOpaque LDKnativeUpdateFailMalformedHTLC; +struct nativeCommitmentSignedOpaque; +typedef struct nativeCommitmentSignedOpaque LDKnativeCommitmentSigned; +struct nativeRevokeAndACKOpaque; +typedef struct nativeRevokeAndACKOpaque LDKnativeRevokeAndACK; +struct nativeUpdateFeeOpaque; +typedef struct nativeUpdateFeeOpaque LDKnativeUpdateFee; +struct nativeDataLossProtectOpaque; +typedef struct nativeDataLossProtectOpaque LDKnativeDataLossProtect; +struct nativeChannelReestablishOpaque; +typedef struct nativeChannelReestablishOpaque LDKnativeChannelReestablish; +struct nativeAnnouncementSignaturesOpaque; +typedef struct nativeAnnouncementSignaturesOpaque LDKnativeAnnouncementSignatures; +struct nativeUnsignedNodeAnnouncementOpaque; +typedef struct nativeUnsignedNodeAnnouncementOpaque LDKnativeUnsignedNodeAnnouncement; +struct nativeNodeAnnouncementOpaque; +typedef struct nativeNodeAnnouncementOpaque LDKnativeNodeAnnouncement; +struct nativeUnsignedChannelAnnouncementOpaque; +typedef struct nativeUnsignedChannelAnnouncementOpaque LDKnativeUnsignedChannelAnnouncement; +struct nativeChannelAnnouncementOpaque; +typedef struct nativeChannelAnnouncementOpaque LDKnativeChannelAnnouncement; +struct nativeUnsignedChannelUpdateOpaque; +typedef struct nativeUnsignedChannelUpdateOpaque LDKnativeUnsignedChannelUpdate; +struct nativeChannelUpdateOpaque; +typedef struct nativeChannelUpdateOpaque LDKnativeChannelUpdate; +struct nativeLightningErrorOpaque; +typedef struct nativeLightningErrorOpaque LDKnativeLightningError; +struct nativeCommitmentUpdateOpaque; +typedef struct nativeCommitmentUpdateOpaque LDKnativeCommitmentUpdate; +struct nativeMessageHandlerOpaque; +typedef struct nativeMessageHandlerOpaque LDKnativeMessageHandler; +struct nativePeerHandleErrorOpaque; +typedef struct nativePeerHandleErrorOpaque LDKnativePeerHandleError; +struct nativePeerManagerOpaque; +typedef struct nativePeerManagerOpaque LDKnativePeerManager; +struct nativeTxCreationKeysOpaque; +typedef struct nativeTxCreationKeysOpaque LDKnativeTxCreationKeys; +struct nativePreCalculatedTxCreationKeysOpaque; +typedef struct nativePreCalculatedTxCreationKeysOpaque LDKnativePreCalculatedTxCreationKeys; +struct nativeChannelPublicKeysOpaque; +typedef struct nativeChannelPublicKeysOpaque LDKnativeChannelPublicKeys; +struct nativeHTLCOutputInCommitmentOpaque; +typedef struct nativeHTLCOutputInCommitmentOpaque LDKnativeHTLCOutputInCommitment; +struct nativeLocalCommitmentTransactionOpaque; +typedef struct nativeLocalCommitmentTransactionOpaque LDKnativeLocalCommitmentTransaction; +struct nativeInitFeaturesOpaque; +typedef struct nativeInitFeaturesOpaque LDKnativeInitFeatures; +struct nativeNodeFeaturesOpaque; +typedef struct nativeNodeFeaturesOpaque LDKnativeNodeFeatures; +struct nativeChannelFeaturesOpaque; +typedef struct nativeChannelFeaturesOpaque LDKnativeChannelFeatures; +struct nativeRouteHopOpaque; +typedef struct nativeRouteHopOpaque LDKnativeRouteHop; +struct nativeRouteOpaque; +typedef struct nativeRouteOpaque LDKnativeRoute; +struct nativeRouteHintOpaque; +typedef struct nativeRouteHintOpaque LDKnativeRouteHint; +struct nativeNetworkGraphOpaque; +typedef struct nativeNetworkGraphOpaque LDKnativeNetworkGraph; +struct nativeLockedNetworkGraphOpaque; +typedef struct nativeLockedNetworkGraphOpaque LDKnativeLockedNetworkGraph; +struct nativeNetGraphMsgHandlerOpaque; +typedef struct nativeNetGraphMsgHandlerOpaque LDKnativeNetGraphMsgHandler; +struct nativeDirectionalChannelInfoOpaque; +typedef struct nativeDirectionalChannelInfoOpaque LDKnativeDirectionalChannelInfo; +struct nativeChannelInfoOpaque; +typedef struct nativeChannelInfoOpaque LDKnativeChannelInfo; +struct nativeRoutingFeesOpaque; +typedef struct nativeRoutingFeesOpaque LDKnativeRoutingFees; +struct nativeNodeAnnouncementInfoOpaque; +typedef struct nativeNodeAnnouncementInfoOpaque LDKnativeNodeAnnouncementInfo; +struct nativeNodeInfoOpaque; +typedef struct nativeNodeInfoOpaque LDKnativeNodeInfo; diff --git a/lightning-c-bindings/src/c_types/derived.rs b/lightning-c-bindings/src/c_types/derived.rs new file mode 100644 index 000000000..8d1e8041b --- /dev/null +++ b/lightning-c-bindings/src/c_types/derived.rs @@ -0,0 +1,405 @@ +#[no_mangle] +pub type CVec_SpendableOutputDescriptorZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_SpendableOutputDescriptorZ_free: extern "C" fn(CVec_SpendableOutputDescriptorZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_MessageSendEventZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_MessageSendEventZ_free: extern "C" fn(CVec_MessageSendEventZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_EventZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_EventZ_free: extern "C" fn(CVec_EventZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type C2Tuple_Txidu32Z = crate::c_types::C2TupleTempl; +#[no_mangle] +pub static C2Tuple_Txidu32Z_free: extern "C" fn(C2Tuple_Txidu32Z) = crate::c_types::C2TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C2Tuple_Txidu32Z_new(a: crate::c_types::ThirtyTwoBytes, b: u32) -> C2Tuple_Txidu32Z { + C2Tuple_Txidu32Z { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type C2Tuple_Scriptu64Z = crate::c_types::C2TupleTempl; +#[no_mangle] +pub static C2Tuple_Scriptu64Z_free: extern "C" fn(C2Tuple_Scriptu64Z) = crate::c_types::C2TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C2Tuple_Scriptu64Z_new(a: crate::c_types::derived::CVec_u8Z, b: u64) -> C2Tuple_Scriptu64Z { + C2Tuple_Scriptu64Z { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type CResult_C2Tuple_Scriptu64ZChainErrorZ = crate::c_types::CResultTempl, crate::chain::chaininterface::ChainError>; +#[no_mangle] +pub static CResult_C2Tuple_Scriptu64ZChainErrorZ_free: extern "C" fn(CResult_C2Tuple_Scriptu64ZChainErrorZ) = crate::c_types::CResultTempl_free::, crate::chain::chaininterface::ChainError>; +#[no_mangle] +pub static CResult_C2Tuple_Scriptu64ZChainErrorZ_ok: extern "C" fn (C2Tuple_Scriptu64Z) -> CResult_C2Tuple_Scriptu64ZChainErrorZ = + crate::c_types::CResultTempl::, crate::chain::chaininterface::ChainError>::ok; + +#[no_mangle] +pub static CResult_C2Tuple_Scriptu64ZChainErrorZ_err: extern "C" fn (crate::chain::chaininterface::ChainError) -> CResult_C2Tuple_Scriptu64ZChainErrorZ = + crate::c_types::CResultTempl::, crate::chain::chaininterface::ChainError>::err; + +#[no_mangle] +pub type CVec_usizeZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_usizeZ_free: extern "C" fn(CVec_usizeZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_TransactionZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_TransactionZ_free: extern "C" fn(CVec_TransactionZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type C2Tuple_u64u64Z = crate::c_types::C2TupleTempl; +#[no_mangle] +pub static C2Tuple_u64u64Z_free: extern "C" fn(C2Tuple_u64u64Z) = crate::c_types::C2TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C2Tuple_u64u64Z_new(a: u64, b: u64) -> C2Tuple_u64u64Z { + C2Tuple_u64u64Z { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type CVec_HTLCOutputInCommitmentZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_HTLCOutputInCommitmentZ_free: extern "C" fn(CVec_HTLCOutputInCommitmentZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_SignatureZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_SignatureZ_free: extern "C" fn(CVec_SignatureZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type C2Tuple_SignatureCVec_SignatureZZ = crate::c_types::C2TupleTempl>; +#[no_mangle] +pub static C2Tuple_SignatureCVec_SignatureZZ_free: extern "C" fn(C2Tuple_SignatureCVec_SignatureZZ) = crate::c_types::C2TupleTempl_free::>; +#[no_mangle] +pub extern "C" fn C2Tuple_SignatureCVec_SignatureZZ_new(a: crate::c_types::Signature, b: crate::c_types::derived::CVec_SignatureZ) -> C2Tuple_SignatureCVec_SignatureZZ { + C2Tuple_SignatureCVec_SignatureZZ { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ = crate::c_types::CResultTempl>, u8>; +#[no_mangle] +pub static CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free: extern "C" fn(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ) = crate::c_types::CResultTempl_free::>, u8>; +#[no_mangle] +pub static CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok: extern "C" fn (C2Tuple_SignatureCVec_SignatureZZ) -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ = + crate::c_types::CResultTempl::>, u8>::ok; + +#[no_mangle] +pub extern "C" fn CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() -> CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { + crate::c_types::CResultTempl::err(0) +} + +#[no_mangle] +pub type CResult_SignatureNoneZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_SignatureNoneZ_free: extern "C" fn(CResult_SignatureNoneZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_SignatureNoneZ_ok: extern "C" fn (crate::c_types::Signature) -> CResult_SignatureNoneZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub extern "C" fn CResult_SignatureNoneZ_err() -> CResult_SignatureNoneZ { + crate::c_types::CResultTempl::err(0) +} + +#[no_mangle] +pub type CResult_CVec_SignatureZNoneZ = crate::c_types::CResultTempl, u8>; +#[no_mangle] +pub static CResult_CVec_SignatureZNoneZ_free: extern "C" fn(CResult_CVec_SignatureZNoneZ) = crate::c_types::CResultTempl_free::, u8>; +#[no_mangle] +pub static CResult_CVec_SignatureZNoneZ_ok: extern "C" fn (CVec_SignatureZ) -> CResult_CVec_SignatureZNoneZ = + crate::c_types::CResultTempl::, u8>::ok; + +#[no_mangle] +pub extern "C" fn CResult_CVec_SignatureZNoneZ_err() -> CResult_CVec_SignatureZNoneZ { + crate::c_types::CResultTempl::err(0) +} + +#[no_mangle] +pub type CResult_NoneAPIErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_NoneAPIErrorZ_free: extern "C" fn(CResult_NoneAPIErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub extern "C" fn CResult_NoneAPIErrorZ_ok() -> CResult_NoneAPIErrorZ { + crate::c_types::CResultTempl::ok(0) +} + +#[no_mangle] +pub static CResult_NoneAPIErrorZ_err: extern "C" fn (crate::util::errors::APIError) -> CResult_NoneAPIErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CVec_ChannelDetailsZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_ChannelDetailsZ_free: extern "C" fn(CVec_ChannelDetailsZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_NonePaymentSendFailureZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_NonePaymentSendFailureZ_free: extern "C" fn(CResult_NonePaymentSendFailureZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub extern "C" fn CResult_NonePaymentSendFailureZ_ok() -> CResult_NonePaymentSendFailureZ { + crate::c_types::CResultTempl::ok(0) +} + +#[no_mangle] +pub static CResult_NonePaymentSendFailureZ_err: extern "C" fn (crate::ln::channelmanager::PaymentSendFailure) -> CResult_NonePaymentSendFailureZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CVec_NetAddressZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_NetAddressZ_free: extern "C" fn(CVec_NetAddressZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_ChannelMonitorZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_ChannelMonitorZ_free: extern "C" fn(CVec_ChannelMonitorZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_NoneChannelMonitorUpdateErrZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_NoneChannelMonitorUpdateErrZ_free: extern "C" fn(CResult_NoneChannelMonitorUpdateErrZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub extern "C" fn CResult_NoneChannelMonitorUpdateErrZ_ok() -> CResult_NoneChannelMonitorUpdateErrZ { + crate::c_types::CResultTempl::ok(0) +} + +#[no_mangle] +pub static CResult_NoneChannelMonitorUpdateErrZ_err: extern "C" fn (crate::ln::channelmonitor::ChannelMonitorUpdateErr) -> CResult_NoneChannelMonitorUpdateErrZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CVec_MonitorEventZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_MonitorEventZ_free: extern "C" fn(CVec_MonitorEventZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_NoneMonitorUpdateErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_NoneMonitorUpdateErrorZ_free: extern "C" fn(CResult_NoneMonitorUpdateErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub extern "C" fn CResult_NoneMonitorUpdateErrorZ_ok() -> CResult_NoneMonitorUpdateErrorZ { + crate::c_types::CResultTempl::ok(0) +} + +#[no_mangle] +pub static CResult_NoneMonitorUpdateErrorZ_err: extern "C" fn (crate::ln::channelmonitor::MonitorUpdateError) -> CResult_NoneMonitorUpdateErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type C2Tuple_OutPointScriptZ = crate::c_types::C2TupleTempl; +#[no_mangle] +pub static C2Tuple_OutPointScriptZ_free: extern "C" fn(C2Tuple_OutPointScriptZ) = crate::c_types::C2TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C2Tuple_OutPointScriptZ_new(a: crate::chain::transaction::OutPoint, b: crate::c_types::derived::CVec_u8Z) -> C2Tuple_OutPointScriptZ { + C2Tuple_OutPointScriptZ { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type CVec_UpdateAddHTLCZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_UpdateAddHTLCZ_free: extern "C" fn(CVec_UpdateAddHTLCZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_UpdateFulfillHTLCZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_UpdateFulfillHTLCZ_free: extern "C" fn(CVec_UpdateFulfillHTLCZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_UpdateFailHTLCZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_UpdateFailHTLCZ_free: extern "C" fn(CVec_UpdateFailHTLCZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_UpdateFailMalformedHTLCZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_UpdateFailMalformedHTLCZ_free: extern "C" fn(CVec_UpdateFailMalformedHTLCZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_boolLightningErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_boolLightningErrorZ_free: extern "C" fn(CResult_boolLightningErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_boolLightningErrorZ_ok: extern "C" fn (bool) -> CResult_boolLightningErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_boolLightningErrorZ_err: extern "C" fn (crate::ln::msgs::LightningError) -> CResult_boolLightningErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ = crate::c_types::C3TupleTempl; +#[no_mangle] +pub static C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free: extern "C" fn(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) = crate::c_types::C3TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: crate::ln::msgs::ChannelAnnouncement, b: crate::ln::msgs::ChannelUpdate, c: crate::ln::msgs::ChannelUpdate) -> C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { + C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + c: Box::into_raw(Box::new(c)), + } +} + +#[no_mangle] +pub type CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ = crate::c_types::CVecTempl>; +#[no_mangle] +pub static CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free: extern "C" fn(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ) = crate::c_types::CVecTempl_free::>; + +#[no_mangle] +pub type CVec_NodeAnnouncementZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_NodeAnnouncementZ_free: extern "C" fn(CVec_NodeAnnouncementZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_PublicKeyZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_PublicKeyZ_free: extern "C" fn(CVec_PublicKeyZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_u8Z = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_u8Z_free: extern "C" fn(CVec_u8Z) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_CVec_u8ZPeerHandleErrorZ = crate::c_types::CResultTempl, crate::ln::peer_handler::PeerHandleError>; +#[no_mangle] +pub static CResult_CVec_u8ZPeerHandleErrorZ_free: extern "C" fn(CResult_CVec_u8ZPeerHandleErrorZ) = crate::c_types::CResultTempl_free::, crate::ln::peer_handler::PeerHandleError>; +#[no_mangle] +pub static CResult_CVec_u8ZPeerHandleErrorZ_ok: extern "C" fn (CVec_u8Z) -> CResult_CVec_u8ZPeerHandleErrorZ = + crate::c_types::CResultTempl::, crate::ln::peer_handler::PeerHandleError>::ok; + +#[no_mangle] +pub static CResult_CVec_u8ZPeerHandleErrorZ_err: extern "C" fn (crate::ln::peer_handler::PeerHandleError) -> CResult_CVec_u8ZPeerHandleErrorZ = + crate::c_types::CResultTempl::, crate::ln::peer_handler::PeerHandleError>::err; + +#[no_mangle] +pub type CResult_NonePeerHandleErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_NonePeerHandleErrorZ_free: extern "C" fn(CResult_NonePeerHandleErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub extern "C" fn CResult_NonePeerHandleErrorZ_ok() -> CResult_NonePeerHandleErrorZ { + crate::c_types::CResultTempl::ok(0) +} + +#[no_mangle] +pub static CResult_NonePeerHandleErrorZ_err: extern "C" fn (crate::ln::peer_handler::PeerHandleError) -> CResult_NonePeerHandleErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CResult_boolPeerHandleErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_boolPeerHandleErrorZ_free: extern "C" fn(CResult_boolPeerHandleErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_boolPeerHandleErrorZ_ok: extern "C" fn (bool) -> CResult_boolPeerHandleErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_boolPeerHandleErrorZ_err: extern "C" fn (crate::ln::peer_handler::PeerHandleError) -> CResult_boolPeerHandleErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CResult_SecretKeySecpErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_SecretKeySecpErrorZ_free: extern "C" fn(CResult_SecretKeySecpErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_SecretKeySecpErrorZ_ok: extern "C" fn (crate::c_types::SecretKey) -> CResult_SecretKeySecpErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_SecretKeySecpErrorZ_err: extern "C" fn (crate::c_types::Secp256k1Error) -> CResult_SecretKeySecpErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CResult_PublicKeySecpErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_PublicKeySecpErrorZ_free: extern "C" fn(CResult_PublicKeySecpErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_PublicKeySecpErrorZ_ok: extern "C" fn (crate::c_types::PublicKey) -> CResult_PublicKeySecpErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_PublicKeySecpErrorZ_err: extern "C" fn (crate::c_types::Secp256k1Error) -> CResult_PublicKeySecpErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CResult_TxCreationKeysSecpErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_TxCreationKeysSecpErrorZ_free: extern "C" fn(CResult_TxCreationKeysSecpErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_TxCreationKeysSecpErrorZ_ok: extern "C" fn (crate::ln::chan_utils::TxCreationKeys) -> CResult_TxCreationKeysSecpErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_TxCreationKeysSecpErrorZ_err: extern "C" fn (crate::c_types::Secp256k1Error) -> CResult_TxCreationKeysSecpErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type C2Tuple_HTLCOutputInCommitmentSignatureZ = crate::c_types::C2TupleTempl; +#[no_mangle] +pub static C2Tuple_HTLCOutputInCommitmentSignatureZ_free: extern "C" fn(C2Tuple_HTLCOutputInCommitmentSignatureZ) = crate::c_types::C2TupleTempl_free::; +#[no_mangle] +pub extern "C" fn C2Tuple_HTLCOutputInCommitmentSignatureZ_new(a: crate::ln::chan_utils::HTLCOutputInCommitment, b: crate::c_types::Signature) -> C2Tuple_HTLCOutputInCommitmentSignatureZ { + C2Tuple_HTLCOutputInCommitmentSignatureZ { + a: Box::into_raw(Box::new(a)), + b: Box::into_raw(Box::new(b)), + } +} + +#[no_mangle] +pub type CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ = crate::c_types::CVecTempl>; +#[no_mangle] +pub static CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ_free: extern "C" fn(CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ) = crate::c_types::CVecTempl_free::>; + +#[no_mangle] +pub type CVec_RouteHopZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_RouteHopZ_free: extern "C" fn(CVec_RouteHopZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CVec_CVec_RouteHopZZ = crate::c_types::CVecTempl>; +#[no_mangle] +pub static CVec_CVec_RouteHopZZ_free: extern "C" fn(CVec_CVec_RouteHopZZ) = crate::c_types::CVecTempl_free::>; + +#[no_mangle] +pub type CVec_RouteHintZ = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_RouteHintZ_free: extern "C" fn(CVec_RouteHintZ) = crate::c_types::CVecTempl_free::; + +#[no_mangle] +pub type CResult_RouteLightningErrorZ = crate::c_types::CResultTempl; +#[no_mangle] +pub static CResult_RouteLightningErrorZ_free: extern "C" fn(CResult_RouteLightningErrorZ) = crate::c_types::CResultTempl_free::; +#[no_mangle] +pub static CResult_RouteLightningErrorZ_ok: extern "C" fn (crate::routing::router::Route) -> CResult_RouteLightningErrorZ = + crate::c_types::CResultTempl::::ok; + +#[no_mangle] +pub static CResult_RouteLightningErrorZ_err: extern "C" fn (crate::ln::msgs::LightningError) -> CResult_RouteLightningErrorZ = + crate::c_types::CResultTempl::::err; + +#[no_mangle] +pub type CVec_u64Z = crate::c_types::CVecTempl; +#[no_mangle] +pub static CVec_u64Z_free: extern "C" fn(CVec_u64Z) = crate::c_types::CVecTempl_free::; + diff --git a/lightning-c-bindings/src/chain/chaininterface.rs b/lightning-c-bindings/src/chain/chaininterface.rs new file mode 100644 index 000000000..5a08dddb8 --- /dev/null +++ b/lightning-c-bindings/src/chain/chaininterface.rs @@ -0,0 +1,606 @@ +//! Traits and utility impls which allow other parts of rust-lightning to interact with the +//! blockchain. +//! +//! Includes traits for monitoring and receiving notifications of new blocks and block +//! disconnections, transaction broadcasting, and feerate information requests. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// Used to give chain error details upstream +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum ChainError { + /// Client doesn't support UTXO lookup (but the chain hash matches our genesis block hash) + NotSupported, + /// Chain isn't the one watched + NotWatched, + /// Tx doesn't exist or is unconfirmed + UnknownTx, +} +use lightning::chain::chaininterface::ChainError as nativeChainError; +impl ChainError { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeChainError { + match self { + ChainError::NotSupported => nativeChainError::NotSupported, + ChainError::NotWatched => nativeChainError::NotWatched, + ChainError::UnknownTx => nativeChainError::UnknownTx, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeChainError { + match self { + ChainError::NotSupported => nativeChainError::NotSupported, + ChainError::NotWatched => nativeChainError::NotWatched, + ChainError::UnknownTx => nativeChainError::UnknownTx, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeChainError) -> Self { + match native { + nativeChainError::NotSupported => ChainError::NotSupported, + nativeChainError::NotWatched => ChainError::NotWatched, + nativeChainError::UnknownTx => ChainError::UnknownTx, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeChainError) -> Self { + match native { + nativeChainError::NotSupported => ChainError::NotSupported, + nativeChainError::NotWatched => ChainError::NotWatched, + nativeChainError::UnknownTx => ChainError::UnknownTx, + } + } +} +/// An interface to request notification of certain scripts as they appear the +/// chain. +/// +/// Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're +/// called from inside the library in response to ChainListener events, P2P events, or timer +/// events). +#[repr(C)] +pub struct ChainWatchInterface { + pub this_arg: *mut c_void, + /// Provides a txid/random-scriptPubKey-in-the-tx which much be watched for. + pub install_watch_tx: extern "C" fn (this_arg: *const c_void, txid: *const [u8; 32], script_pub_key: crate::c_types::u8slice), + /// Provides an outpoint which must be watched for, providing any transactions which spend the + /// given outpoint. + pub install_watch_outpoint: extern "C" fn (this_arg: *const c_void, outpoint: crate::c_types::derived::C2Tuple_Txidu32Z, out_script: crate::c_types::u8slice), + /// Indicates that a listener needs to see all transactions. + pub watch_all_txn: extern "C" fn (this_arg: *const c_void), + /// Gets the script and value in satoshis for a given unspent transaction output given a + /// short_channel_id (aka unspent_tx_output_identier). For BTC/tBTC channels the top three + /// bytes are the block height, the next 3 the transaction index within the block, and the + /// final two the output within the transaction. + #[must_use] + pub get_chain_utxo: extern "C" fn (this_arg: *const c_void, genesis_hash: crate::c_types::ThirtyTwoBytes, unspent_tx_output_identifier: u64) -> crate::c_types::derived::CResult_C2Tuple_Scriptu64ZChainErrorZ, + /// Gets the list of transaction indices within a given block that the ChainWatchInterface is + /// watching for. + #[must_use] + pub filter_block: extern "C" fn (this_arg: *const c_void, block: crate::c_types::u8slice) -> crate::c_types::derived::CVec_usizeZ, + /// Returns a usize that changes when the ChainWatchInterface's watched data is modified. + /// Users of `filter_block` should pre-save a copy of `reentered`'s return value and use it to + /// determine whether they need to re-filter a given block. + #[must_use] + pub reentered: extern "C" fn (this_arg: *const c_void) -> usize, + pub free: Option, +} +unsafe impl Sync for ChainWatchInterface {} +unsafe impl Send for ChainWatchInterface {} + +use lightning::chain::chaininterface::ChainWatchInterface as rustChainWatchInterface; +impl rustChainWatchInterface for ChainWatchInterface { + fn install_watch_tx(&self, txid: &bitcoin::hash_types::Txid, script_pub_key: &bitcoin::blockdata::script::Script) { + (self.install_watch_tx)(self.this_arg, txid.as_inner(), crate::c_types::u8slice::from_slice(&script_pub_key[..])) + } + fn install_watch_outpoint(&self, outpoint: (bitcoin::hash_types::Txid, u32), out_script: &bitcoin::blockdata::script::Script) { + let (mut orig_outpoint_0, mut orig_outpoint_1) = outpoint; let mut local_outpoint = (crate::c_types::ThirtyTwoBytes { data: orig_outpoint_0.into_inner() }, orig_outpoint_1).into(); + (self.install_watch_outpoint)(self.this_arg, local_outpoint, crate::c_types::u8slice::from_slice(&out_script[..])) + } + fn watch_all_txn(&self) { + (self.watch_all_txn)(self.this_arg) + } + fn get_chain_utxo(&self, genesis_hash: bitcoin::hash_types::BlockHash, unspent_tx_output_identifier: u64) -> Result<(bitcoin::blockdata::script::Script, u64), lightning::chain::chaininterface::ChainError> { + let mut ret = (self.get_chain_utxo)(self.this_arg, crate::c_types::ThirtyTwoBytes { data: genesis_hash.into_inner() }, unspent_tx_output_identifier); + 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(ret.contents.result.take_ptr()) }).to_rust(); let mut local_ret_0 = (::bitcoin::blockdata::script::Script::from(orig_ret_0_0.into_rust()), orig_ret_0_1); local_ret_0 }), false => Err( { (*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).into_native() })}; + local_ret + } + fn filter_block(&self, block: &bitcoin::blockdata::block::Block) -> Vec { + let mut local_block = ::bitcoin::consensus::encode::serialize(block); + let mut ret = (self.filter_block)(self.this_arg, crate::c_types::u8slice::from_slice(&local_block)); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item }); }; + local_ret + } + fn reentered(&self) -> usize { + let mut ret = (self.reentered)(self.this_arg); + ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for ChainWatchInterface { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn ChainWatchInterface_free(this_ptr: ChainWatchInterface) { } +impl Drop for ChainWatchInterface { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// An interface to send a transaction to the Bitcoin network. +#[repr(C)] +pub struct BroadcasterInterface { + pub this_arg: *mut c_void, + /// Sends a transaction out to (hopefully) be mined. + pub broadcast_transaction: extern "C" fn (this_arg: *const c_void, tx: crate::c_types::Transaction), + pub free: Option, +} +unsafe impl Sync for BroadcasterInterface {} +unsafe impl Send for BroadcasterInterface {} + +use lightning::chain::chaininterface::BroadcasterInterface as rustBroadcasterInterface; +impl rustBroadcasterInterface for BroadcasterInterface { + fn broadcast_transaction(&self, tx: &bitcoin::blockdata::transaction::Transaction) { + let mut local_tx = ::bitcoin::consensus::encode::serialize(tx); + (self.broadcast_transaction)(self.this_arg, crate::c_types::Transaction::from_slice(&local_tx)) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for BroadcasterInterface { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn BroadcasterInterface_free(this_ptr: BroadcasterInterface) { } +impl Drop for BroadcasterInterface { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// A trait indicating a desire to listen for events from the chain +#[repr(C)] +pub struct ChainListener { + pub this_arg: *mut c_void, + /// Notifies a listener that a block was connected. + /// + /// The txn_matched array should be set to references to transactions which matched the + /// relevant installed watch outpoints/txn, or the full set of transactions in the block. + /// + /// Note that if txn_matched includes only matched transactions, and a new + /// transaction/outpoint is watched during a block_connected call, the block *must* be + /// re-scanned with the new transaction/outpoints and block_connected should be called + /// again with the same header and (at least) the new transactions. + /// + /// Note that if non-new transaction/outpoints are be registered during a call, a second call + /// *must not* happen. + /// + /// This also means those counting confirmations using block_connected callbacks should watch + /// for duplicate headers and not count them towards confirmations! + pub block_connected: extern "C" fn (this_arg: *const c_void, header: *const [u8; 80], height: u32, txn_matched: crate::c_types::derived::CVec_TransactionZ, indexes_of_txn_matched: crate::c_types::usizeslice), + /// Notifies a listener that a block was disconnected. + /// Unlike block_connected, this *must* never be called twice for the same disconnect event. + /// Height must be the one of the block which was disconnected (not new height of the best chain) + pub block_disconnected: extern "C" fn (this_arg: *const c_void, header: *const [u8; 80], disconnected_height: u32), + pub free: Option, +} +unsafe impl Sync for ChainListener {} +unsafe impl Send for ChainListener {} + +use lightning::chain::chaininterface::ChainListener as rustChainListener; +impl rustChainListener for ChainListener { + fn block_connected(&self, header: &bitcoin::blockdata::block::BlockHeader, height: u32, txn_matched: &[&bitcoin::blockdata::transaction::Transaction], indexes_of_txn_matched: &[usize]) { + let mut local_header = { let mut s = [0u8; 80]; s[..].copy_from_slice(&::bitcoin::consensus::encode::serialize(header)); s }; + let mut local_txn_matched = Vec::new(); for item in txn_matched.iter() { local_txn_matched.push( { let mut local_txn_matched_0 = ::bitcoin::consensus::encode::serialize(&**item); local_txn_matched_0.into() }); }; + let mut local_indexes_of_txn_matched = crate::c_types::usizeslice::from_slice(indexes_of_txn_matched); + (self.block_connected)(self.this_arg, &local_header, height, local_txn_matched.into(), local_indexes_of_txn_matched) + } + fn block_disconnected(&self, header: &bitcoin::blockdata::block::BlockHeader, disconnected_height: u32) { + let mut local_header = { let mut s = [0u8; 80]; s[..].copy_from_slice(&::bitcoin::consensus::encode::serialize(header)); s }; + (self.block_disconnected)(self.this_arg, &local_header, disconnected_height) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for ChainListener { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn ChainListener_free(this_ptr: ChainListener) { } +impl Drop for ChainListener { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// An enum that represents the speed at which we want a transaction to confirm used for feerate +/// estimation. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum ConfirmationTarget { + /// We are happy with this transaction confirming slowly when feerate drops some. + Background, + /// We'd like this transaction to confirm without major delay, but 12-18 blocks is fine. + Normal, + /// We'd like this transaction to confirm in the next few blocks. + HighPriority, +} +use lightning::chain::chaininterface::ConfirmationTarget as nativeConfirmationTarget; +impl ConfirmationTarget { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeConfirmationTarget { + match self { + ConfirmationTarget::Background => nativeConfirmationTarget::Background, + ConfirmationTarget::Normal => nativeConfirmationTarget::Normal, + ConfirmationTarget::HighPriority => nativeConfirmationTarget::HighPriority, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeConfirmationTarget { + match self { + ConfirmationTarget::Background => nativeConfirmationTarget::Background, + ConfirmationTarget::Normal => nativeConfirmationTarget::Normal, + ConfirmationTarget::HighPriority => nativeConfirmationTarget::HighPriority, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeConfirmationTarget) -> Self { + match native { + nativeConfirmationTarget::Background => ConfirmationTarget::Background, + nativeConfirmationTarget::Normal => ConfirmationTarget::Normal, + nativeConfirmationTarget::HighPriority => ConfirmationTarget::HighPriority, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeConfirmationTarget) -> Self { + match native { + nativeConfirmationTarget::Background => ConfirmationTarget::Background, + nativeConfirmationTarget::Normal => ConfirmationTarget::Normal, + nativeConfirmationTarget::HighPriority => ConfirmationTarget::HighPriority, + } + } +} +/// A trait which should be implemented to provide feerate information on a number of time +/// horizons. +/// +/// Note that all of the functions implemented here *must* be reentrant-safe (obviously - they're +/// called from inside the library in response to ChainListener events, P2P events, or timer +/// events). +#[repr(C)] +pub struct FeeEstimator { + pub this_arg: *mut c_void, + /// Gets estimated satoshis of fee required per 1000 Weight-Units. + /// + /// Must be no smaller than 253 (ie 1 satoshi-per-byte rounded up to ensure later round-downs + /// don't put us below 1 satoshi-per-byte). + /// + /// This translates to: + /// * satoshis-per-byte * 250 + /// * ceil(satoshis-per-kbyte / 4) + #[must_use] + pub get_est_sat_per_1000_weight: extern "C" fn (this_arg: *const c_void, confirmation_target: crate::chain::chaininterface::ConfirmationTarget) -> u32, + pub free: Option, +} +unsafe impl Sync for FeeEstimator {} +unsafe impl Send for FeeEstimator {} + +use lightning::chain::chaininterface::FeeEstimator as rustFeeEstimator; +impl rustFeeEstimator for FeeEstimator { + fn get_est_sat_per_1000_weight(&self, confirmation_target: lightning::chain::chaininterface::ConfirmationTarget) -> u32 { + let mut ret = (self.get_est_sat_per_1000_weight)(self.this_arg, crate::chain::chaininterface::ConfirmationTarget::native_into(confirmation_target)); + ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for FeeEstimator { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn FeeEstimator_free(this_ptr: FeeEstimator) { } +impl Drop for FeeEstimator { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} + +#[no_mangle] +pub static MIN_RELAY_FEE_SAT_PER_1000_WEIGHT: u64 = lightning::chain::chaininterface::MIN_RELAY_FEE_SAT_PER_1000_WEIGHT; + +use lightning::chain::chaininterface::ChainWatchedUtil as nativeChainWatchedUtilImport; +type nativeChainWatchedUtil = nativeChainWatchedUtilImport; + +/// Utility for tracking registered txn/outpoints and checking for matches +#[must_use] +#[repr(C)] +pub struct ChainWatchedUtil { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChainWatchedUtil, + pub is_owned: bool, +} + +impl Drop for ChainWatchedUtil { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_free(this_ptr: ChainWatchedUtil) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChainWatchedUtil_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChainWatchedUtil); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChainWatchedUtil { + pub(crate) fn take_ptr(mut self) -> *mut nativeChainWatchedUtil { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Constructs an empty (watches nothing) ChainWatchedUtil +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_new() -> ChainWatchedUtil { + let mut ret = lightning::chain::chaininterface::ChainWatchedUtil::new(); + ChainWatchedUtil { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Registers a tx for monitoring, returning true if it was a new tx and false if we'd already +/// been watching for it. +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_register_tx(this_arg: &mut ChainWatchedUtil, txid: *const [u8; 32], script_pub_key: crate::c_types::u8slice) -> bool { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChainWatchedUtil)) }.register_tx(&::bitcoin::hash_types::Txid::from_slice(&unsafe { &*txid }[..]).unwrap(), &::bitcoin::blockdata::script::Script::from(Vec::from(script_pub_key.to_slice()))); + ret +} + +/// Registers an outpoint for monitoring, returning true if it was a new outpoint and false if +/// we'd already been watching for it +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_register_outpoint(this_arg: &mut ChainWatchedUtil, mut outpoint: crate::c_types::derived::C2Tuple_Txidu32Z, _script_pub_key: crate::c_types::u8slice) -> bool { + let (mut orig_outpoint_0, mut orig_outpoint_1) = outpoint.to_rust(); let mut local_outpoint = (::bitcoin::hash_types::Txid::from_slice(&orig_outpoint_0.data[..]).unwrap(), orig_outpoint_1); + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChainWatchedUtil)) }.register_outpoint(local_outpoint, &::bitcoin::blockdata::script::Script::from(Vec::from(_script_pub_key.to_slice()))); + ret +} + +/// Sets us to match all transactions, returning true if this is a new setting and false if +/// we'd already been set to match everything. +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_watch_all(this_arg: &mut ChainWatchedUtil) -> bool { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChainWatchedUtil)) }.watch_all(); + ret +} + +/// Checks if a given transaction matches the current filter. +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchedUtil_does_match_tx(this_arg: &ChainWatchedUtil, tx: crate::c_types::Transaction) -> bool { + let mut ret = unsafe { &*this_arg.inner }.does_match_tx(&tx.into_bitcoin()); + ret +} + + +use lightning::chain::chaininterface::BlockNotifier as nativeBlockNotifierImport; +type nativeBlockNotifier = nativeBlockNotifierImport<'static, crate::chain::chaininterface::ChainListener, crate::chain::chaininterface::ChainWatchInterface>; + +/// Utility for notifying listeners about new blocks, and handling block rescans if new watch +/// data is registered. +/// +/// Rather than using a plain BlockNotifier, it is preferable to use either a BlockNotifierArc +/// or a BlockNotifierRef for conciseness. See their documentation for more details, but essentially +/// you should default to using a BlockNotifierRef, and use a BlockNotifierArc instead when you +/// require ChainListeners with static lifetimes, such as when you're using lightning-net-tokio. +#[must_use] +#[repr(C)] +pub struct BlockNotifier { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeBlockNotifier, + pub is_owned: bool, +} + +impl Drop for BlockNotifier { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn BlockNotifier_free(this_ptr: BlockNotifier) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn BlockNotifier_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeBlockNotifier); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl BlockNotifier { + pub(crate) fn take_ptr(mut self) -> *mut nativeBlockNotifier { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Constructs a new BlockNotifier without any listeners. +#[must_use] +#[no_mangle] +pub extern "C" fn BlockNotifier_new(mut chain_monitor: crate::chain::chaininterface::ChainWatchInterface) -> crate::chain::chaininterface::BlockNotifier { + let mut ret = lightning::chain::chaininterface::BlockNotifier::new(chain_monitor); + crate::chain::chaininterface::BlockNotifier { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Register the given listener to receive events. +#[no_mangle] +pub extern "C" fn BlockNotifier_register_listener(this_arg: &BlockNotifier, mut listener: crate::chain::chaininterface::ChainListener) { + unsafe { &*this_arg.inner }.register_listener(listener) +} + +/// Notify listeners that a block was connected given a full, unfiltered block. +/// +/// Handles re-scanning the block and calling block_connected again if listeners register new +/// watch data during the callbacks for you (see ChainListener::block_connected for more info). +#[no_mangle] +pub extern "C" fn BlockNotifier_block_connected(this_arg: &BlockNotifier, block: crate::c_types::u8slice, mut height: u32) { + unsafe { &*this_arg.inner }.block_connected(&::bitcoin::consensus::encode::deserialize(block.to_slice()).unwrap(), height) +} + +/// Notify listeners that a block was connected, given pre-filtered list of transactions in the +/// block which matched the filter (probably using does_match_tx). +/// +/// Returns true if notified listeners registered additional watch data (implying that the +/// block must be re-scanned and this function called again prior to further block_connected +/// calls, see ChainListener::block_connected for more info). +#[must_use] +#[no_mangle] +pub extern "C" fn BlockNotifier_block_connected_checked(this_arg: &BlockNotifier, header: *const [u8; 80], mut height: u32, mut txn_matched: crate::c_types::derived::CVec_TransactionZ, mut indexes_of_txn_matched: crate::c_types::usizeslice) -> bool { + let mut local_txn_matched = Vec::new(); for mut item in txn_matched.into_rust().drain(..) { local_txn_matched.push( { ::bitcoin::consensus::encode::deserialize(&item.into_rust()[..]).unwrap() }); }; + let mut ret = unsafe { &*this_arg.inner }.block_connected_checked(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), height, &local_txn_matched.iter().collect::>()[..], indexes_of_txn_matched.to_slice()); + ret +} + +/// Notify listeners that a block was disconnected. +#[no_mangle] +pub extern "C" fn BlockNotifier_block_disconnected(this_arg: &BlockNotifier, header: *const [u8; 80], mut disconnected_height: u32) { + unsafe { &*this_arg.inner }.block_disconnected(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), disconnected_height) +} + + +use lightning::chain::chaininterface::ChainWatchInterfaceUtil as nativeChainWatchInterfaceUtilImport; +type nativeChainWatchInterfaceUtil = nativeChainWatchInterfaceUtilImport; + +/// Utility to capture some common parts of ChainWatchInterface implementors. +/// +/// Keeping a local copy of this in a ChainWatchInterface implementor is likely useful. +#[must_use] +#[repr(C)] +pub struct ChainWatchInterfaceUtil { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChainWatchInterfaceUtil, + pub is_owned: bool, +} + +impl Drop for ChainWatchInterfaceUtil { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChainWatchInterfaceUtil_free(this_ptr: ChainWatchInterfaceUtil) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChainWatchInterfaceUtil_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChainWatchInterfaceUtil); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChainWatchInterfaceUtil { + pub(crate) fn take_ptr(mut self) -> *mut nativeChainWatchInterfaceUtil { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +#[no_mangle] +pub extern "C" fn ChainWatchInterfaceUtil_as_ChainWatchInterface(this_arg: *const ChainWatchInterfaceUtil) -> crate::chain::chaininterface::ChainWatchInterface { + crate::chain::chaininterface::ChainWatchInterface { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + install_watch_tx: ChainWatchInterfaceUtil_ChainWatchInterface_install_watch_tx, + install_watch_outpoint: ChainWatchInterfaceUtil_ChainWatchInterface_install_watch_outpoint, + watch_all_txn: ChainWatchInterfaceUtil_ChainWatchInterface_watch_all_txn, + get_chain_utxo: ChainWatchInterfaceUtil_ChainWatchInterface_get_chain_utxo, + filter_block: ChainWatchInterfaceUtil_ChainWatchInterface_filter_block, + reentered: ChainWatchInterfaceUtil_ChainWatchInterface_reentered, + } +} +use lightning::chain::chaininterface::ChainWatchInterface as ChainWatchInterfaceTraitImport; +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_install_watch_tx(this_arg: *const c_void, txid: *const [u8; 32], script_pub_key: crate::c_types::u8slice) { + unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.install_watch_tx(&::bitcoin::hash_types::Txid::from_slice(&unsafe { &*txid }[..]).unwrap(), &::bitcoin::blockdata::script::Script::from(Vec::from(script_pub_key.to_slice()))) +} +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_install_watch_outpoint(this_arg: *const c_void, mut outpoint: crate::c_types::derived::C2Tuple_Txidu32Z, out_script: crate::c_types::u8slice) { + let (mut orig_outpoint_0, mut orig_outpoint_1) = outpoint.to_rust(); let mut local_outpoint = (::bitcoin::hash_types::Txid::from_slice(&orig_outpoint_0.data[..]).unwrap(), orig_outpoint_1); + unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.install_watch_outpoint(local_outpoint, &::bitcoin::blockdata::script::Script::from(Vec::from(out_script.to_slice()))) +} +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_watch_all_txn(this_arg: *const c_void) { + unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.watch_all_txn() +} +#[must_use] +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_get_chain_utxo(this_arg: *const c_void, mut genesis_hash: crate::c_types::ThirtyTwoBytes, mut _unspent_tx_output_identifier: u64) -> crate::c_types::derived::CResult_C2Tuple_Scriptu64ZChainErrorZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.get_chain_utxo(::bitcoin::hash_types::BlockHash::from_slice(&genesis_hash.data[..]).unwrap(), _unspent_tx_output_identifier); + 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_ret_0 = (orig_ret_0_0.into_bytes().into(), orig_ret_0_1).into(); local_ret_0 }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::chain::chaininterface::ChainError::native_into(e) }) }; + local_ret +} +#[must_use] +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_filter_block(this_arg: *const c_void, block: crate::c_types::u8slice) -> crate::c_types::derived::CVec_usizeZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.filter_block(&::bitcoin::consensus::encode::deserialize(block.to_slice()).unwrap()); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { item }); }; + local_ret.into() +} +#[must_use] +extern "C" fn ChainWatchInterfaceUtil_ChainWatchInterface_reentered(this_arg: *const c_void) -> usize { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChainWatchInterfaceUtil) }.reentered(); + ret +} + +/// Creates a new ChainWatchInterfaceUtil for the given network +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchInterfaceUtil_new(mut network: crate::bitcoin::network::Network) -> crate::chain::chaininterface::ChainWatchInterfaceUtil { + let mut ret = lightning::chain::chaininterface::ChainWatchInterfaceUtil::new(network.into_bitcoin()); + crate::chain::chaininterface::ChainWatchInterfaceUtil { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Checks if a given transaction matches the current filter. +#[must_use] +#[no_mangle] +pub extern "C" fn ChainWatchInterfaceUtil_does_match_tx(this_arg: &ChainWatchInterfaceUtil, tx: crate::c_types::Transaction) -> bool { + let mut ret = unsafe { &*this_arg.inner }.does_match_tx(&tx.into_bitcoin()); + ret +} + diff --git a/lightning-c-bindings/src/chain/keysinterface.rs b/lightning-c-bindings/src/chain/keysinterface.rs new file mode 100644 index 000000000..9cc9360bd --- /dev/null +++ b/lightning-c-bindings/src/chain/keysinterface.rs @@ -0,0 +1,938 @@ +//! keysinterface provides keys into rust-lightning and defines some useful enums which describe +//! spendable on-chain outputs which the user owns and is responsible for using just as any other +//! on-chain output which is theirs. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// When on-chain outputs are created by rust-lightning (which our counterparty is not able to +/// claim at any point in the future) an event is generated which you must track and be able to +/// spend on-chain. The information needed to do this is provided in this enum, including the +/// outpoint describing which txid and output index is available, the full output which exists at +/// that txid/index, and any keys or other information required to sign. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum SpendableOutputDescriptor { + /// An output to a script which was provided via KeysInterface, thus you should already know + /// how to spend it. No keys are provided as rust-lightning was never given any keys - only the + /// script_pubkey as it appears in the output. + /// These may include outputs from a transaction punishing our counterparty or claiming an HTLC + /// on-chain using the payment preimage or after it has timed out. + StaticOutput { + outpoint: crate::chain::transaction::OutPoint, + output: crate::c_types::TxOut, + }, + /// An output to a P2WSH script which can be spent with a single signature after a CSV delay. + /// + /// The witness in the spending input should be: + /// (MINIMALIF standard rule) + /// + /// Note that the nSequence field in the spending input must be set to to_self_delay + /// (which means the transaction is not broadcastable until at least to_self_delay + /// blocks after the outpoint confirms). + /// + /// These are generally the result of a \"revocable\" output to us, spendable only by us unless + /// it is an output from an old state which we broadcast (which should never happen). + /// + /// To derive the delayed_payment key which is used to sign for this input, you must pass the + /// local delayed_payment_base_key (ie the private key which corresponds to the pubkey in + /// ChannelKeys::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to + /// chan_utils::derive_private_key. The public key can be generated without the secret key + /// using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in + /// ChannelKeys::pubkeys(). + /// + /// To derive the remote_revocation_pubkey provided here (which is used in the witness + /// script generation), you must pass the remote revocation_basepoint (which appears in the + /// call to ChannelKeys::on_accept) and the provided per_commitment point + /// to chan_utils::derive_public_revocation_key. + /// + /// The witness script which is hashed and included in the output script_pubkey may be + /// regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey + /// (derived as above), and the to_self_delay contained here to + /// chan_utils::get_revokeable_redeemscript. + DynamicOutputP2WSH { + outpoint: crate::chain::transaction::OutPoint, + per_commitment_point: crate::c_types::PublicKey, + to_self_delay: u16, + output: crate::c_types::TxOut, + key_derivation_params: crate::c_types::derived::C2Tuple_u64u64Z, + remote_revocation_pubkey: crate::c_types::PublicKey, + }, + /// An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which + /// corresponds to the public key in ChannelKeys::pubkeys().payment_point). + /// The witness in the spending input, is, thus, simply: + /// + /// + /// These are generally the result of our counterparty having broadcast the current state, + /// allowing us to claim the non-HTLC-encumbered outputs immediately. + StaticOutputRemotePayment { + outpoint: crate::chain::transaction::OutPoint, + output: crate::c_types::TxOut, + key_derivation_params: crate::c_types::derived::C2Tuple_u64u64Z, + }, +} +use lightning::chain::keysinterface::SpendableOutputDescriptor as nativeSpendableOutputDescriptor; +impl SpendableOutputDescriptor { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeSpendableOutputDescriptor { + match self { + SpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut output_nonref = (*output).clone(); + nativeSpendableOutputDescriptor::StaticOutput { + outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_ptr()) }, + output: output_nonref.into_rust(), + } + }, + SpendableOutputDescriptor::DynamicOutputP2WSH {ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut per_commitment_point_nonref = (*per_commitment_point).clone(); + let mut to_self_delay_nonref = (*to_self_delay).clone(); + let mut output_nonref = (*output).clone(); + let mut key_derivation_params_nonref = (*key_derivation_params).clone(); + 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); + let mut remote_revocation_pubkey_nonref = (*remote_revocation_pubkey).clone(); + nativeSpendableOutputDescriptor::DynamicOutputP2WSH { + outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_ptr()) }, + per_commitment_point: per_commitment_point_nonref.into_rust(), + to_self_delay: to_self_delay_nonref, + output: output_nonref.into_rust(), + key_derivation_params: local_key_derivation_params_nonref, + remote_revocation_pubkey: remote_revocation_pubkey_nonref.into_rust(), + } + }, + SpendableOutputDescriptor::StaticOutputRemotePayment {ref outpoint, ref output, ref key_derivation_params, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut output_nonref = (*output).clone(); + let mut key_derivation_params_nonref = (*key_derivation_params).clone(); + 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); + nativeSpendableOutputDescriptor::StaticOutputRemotePayment { + outpoint: *unsafe { Box::from_raw(outpoint_nonref.take_ptr()) }, + output: output_nonref.into_rust(), + key_derivation_params: local_key_derivation_params_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeSpendableOutputDescriptor { + match self { + SpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => { + nativeSpendableOutputDescriptor::StaticOutput { + outpoint: *unsafe { Box::from_raw(outpoint.take_ptr()) }, + output: output.into_rust(), + } + }, + SpendableOutputDescriptor::DynamicOutputP2WSH {mut outpoint, mut per_commitment_point, mut to_self_delay, mut output, mut key_derivation_params, mut remote_revocation_pubkey, } => { + 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); + nativeSpendableOutputDescriptor::DynamicOutputP2WSH { + outpoint: *unsafe { Box::from_raw(outpoint.take_ptr()) }, + per_commitment_point: per_commitment_point.into_rust(), + to_self_delay: to_self_delay, + output: output.into_rust(), + key_derivation_params: local_key_derivation_params, + remote_revocation_pubkey: remote_revocation_pubkey.into_rust(), + } + }, + SpendableOutputDescriptor::StaticOutputRemotePayment {mut outpoint, mut output, mut key_derivation_params, } => { + 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); + nativeSpendableOutputDescriptor::StaticOutputRemotePayment { + outpoint: *unsafe { Box::from_raw(outpoint.take_ptr()) }, + output: output.into_rust(), + key_derivation_params: local_key_derivation_params, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeSpendableOutputDescriptor) -> Self { + match native { + nativeSpendableOutputDescriptor::StaticOutput {ref outpoint, ref output, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut output_nonref = (*output).clone(); + SpendableOutputDescriptor::StaticOutput { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true }, + output: crate::c_types::TxOut::from_rust(output_nonref), + } + }, + nativeSpendableOutputDescriptor::DynamicOutputP2WSH {ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut per_commitment_point_nonref = (*per_commitment_point).clone(); + let mut to_self_delay_nonref = (*to_self_delay).clone(); + let mut output_nonref = (*output).clone(); + let mut key_derivation_params_nonref = (*key_derivation_params).clone(); + 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(); + let mut remote_revocation_pubkey_nonref = (*remote_revocation_pubkey).clone(); + SpendableOutputDescriptor::DynamicOutputP2WSH { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true }, + per_commitment_point: crate::c_types::PublicKey::from_rust(&per_commitment_point_nonref), + to_self_delay: to_self_delay_nonref, + output: crate::c_types::TxOut::from_rust(output_nonref), + key_derivation_params: local_key_derivation_params_nonref, + remote_revocation_pubkey: crate::c_types::PublicKey::from_rust(&remote_revocation_pubkey_nonref), + } + }, + nativeSpendableOutputDescriptor::StaticOutputRemotePayment {ref outpoint, ref output, ref key_derivation_params, } => { + let mut outpoint_nonref = (*outpoint).clone(); + let mut output_nonref = (*output).clone(); + let mut key_derivation_params_nonref = (*key_derivation_params).clone(); + 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(); + SpendableOutputDescriptor::StaticOutputRemotePayment { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint_nonref)), is_owned: true }, + output: crate::c_types::TxOut::from_rust(output_nonref), + key_derivation_params: local_key_derivation_params_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeSpendableOutputDescriptor) -> Self { + match native { + nativeSpendableOutputDescriptor::StaticOutput {mut outpoint, mut output, } => { + SpendableOutputDescriptor::StaticOutput { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true }, + output: crate::c_types::TxOut::from_rust(output), + } + }, + nativeSpendableOutputDescriptor::DynamicOutputP2WSH {mut outpoint, mut per_commitment_point, mut to_self_delay, mut output, mut key_derivation_params, mut remote_revocation_pubkey, } => { + 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(); + SpendableOutputDescriptor::DynamicOutputP2WSH { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true }, + per_commitment_point: crate::c_types::PublicKey::from_rust(&per_commitment_point), + to_self_delay: to_self_delay, + output: crate::c_types::TxOut::from_rust(output), + key_derivation_params: local_key_derivation_params, + remote_revocation_pubkey: crate::c_types::PublicKey::from_rust(&remote_revocation_pubkey), + } + }, + nativeSpendableOutputDescriptor::StaticOutputRemotePayment {mut outpoint, mut output, mut key_derivation_params, } => { + 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(); + SpendableOutputDescriptor::StaticOutputRemotePayment { + outpoint: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(outpoint)), is_owned: true }, + output: crate::c_types::TxOut::from_rust(output), + key_derivation_params: local_key_derivation_params, + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn SpendableOutputDescriptor_free(this_ptr: SpendableOutputDescriptor) { } +/// Set of lightning keys needed to operate a channel as described in BOLT 3. +/// +/// Signing services could be implemented on a hardware wallet. In this case, +/// the current ChannelKeys would be a front-end on top of a communication +/// channel connected to your secure device and lightning key material wouldn't +/// reside on a hot server. Nevertheless, a this deployment would still need +/// to trust the ChannelManager to avoid loss of funds as this latest component +/// could ask to sign commitment transaction with HTLCs paying to attacker pubkeys. +/// +/// A more secure iteration would be to use hashlock (or payment points) to pair +/// invoice/incoming HTLCs with outgoing HTLCs to implement a no-trust-ChannelManager +/// at the price of more state and computation on the hardware wallet side. In the future, +/// we are looking forward to design such interface. +/// +/// In any case, ChannelMonitor or fallback watchtowers are always going to be trusted +/// to act, as liveness and breach reply correctness are always going to be hard requirements +/// of LN security model, orthogonal of key management issues. +/// +/// If you're implementing a custom signer, you almost certainly want to implement +/// Readable/Writable to serialize out a unique reference to this set of keys so +/// that you can serialize the full ChannelManager object. +/// +#[repr(C)] +pub struct ChannelKeys { + pub this_arg: *mut c_void, + /// Gets the per-commitment point for a specific commitment number + /// + /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards. + #[must_use] + pub get_per_commitment_point: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::PublicKey, + /// Gets the commitment secret for a specific commitment number as part of the revocation process + /// + /// An external signer implementation should error here if the commitment was already signed + /// and should refuse to sign it in the future. + /// + /// May be called more than once for the same index. + /// + /// Note that the commitment number starts at (1 << 48) - 1 and counts backwards. + /// TODO: return a Result so we can signal a validation error + #[must_use] + pub release_commitment_secret: extern "C" fn (this_arg: *const c_void, idx: u64) -> crate::c_types::ThirtyTwoBytes, + /// Gets the local channel public keys and basepoints + pub pubkeys: crate::ln::chan_utils::ChannelPublicKeys, + /// Fill in the pubkeys field as a reference to it will be given to Rust after this returns + /// Note that this takes a pointer to this object, not the this_ptr like other methods do + /// This function pointer may be NULL if pubkeys is filled in when this object is created and never needs updating. + pub set_pubkeys: Option, + /// Gets arbitrary identifiers describing the set of keys which are provided back to you in + /// some SpendableOutputDescriptor types. These should be sufficient to identify this + /// ChannelKeys object uniquely and lookup or re-derive its keys. + #[must_use] + pub key_derivation_params: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::C2Tuple_u64u64Z, + /// Create a signature for a remote commitment transaction and associated HTLC transactions. + /// + /// Note that if signing fails or is rejected, the channel will be force-closed. + #[must_use] + pub sign_remote_commitment: extern "C" fn (this_arg: *const c_void, feerate_per_kw: u32, commitment_tx: crate::c_types::Transaction, keys: &crate::ln::chan_utils::PreCalculatedTxCreationKeys, htlcs: crate::c_types::derived::CVec_HTLCOutputInCommitmentZ) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ, + /// Create a signature for a local commitment transaction. This will only ever be called with + /// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees + /// that it will not be called multiple times. + /// An external signer implementation should check that the commitment has not been revoked. + #[must_use] + pub sign_local_commitment: extern "C" fn (this_arg: *const c_void, local_commitment_tx: &crate::ln::chan_utils::LocalCommitmentTransaction) -> crate::c_types::derived::CResult_SignatureNoneZ, + /// Create a signature for each HTLC transaction spending a local commitment transaction. + /// + /// Unlike sign_local_commitment, this may be called multiple times with *different* + /// local_commitment_tx values. While this will never be called with a revoked + /// local_commitment_tx, it is possible that it is called with the second-latest + /// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary + /// ChannelMonitor decided to broadcast before it had been updated to the latest. + /// + /// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in + /// local_commitment_tx. For those HTLCs which have transaction_output_index set to None + /// (implying they were considered dust at the time the commitment transaction was negotiated), + /// a corresponding None should be included in the return value. All other positions in the + /// return value must contain a signature. + #[must_use] + pub sign_local_commitment_htlc_transactions: extern "C" fn (this_arg: *const c_void, local_commitment_tx: &crate::ln::chan_utils::LocalCommitmentTransaction) -> crate::c_types::derived::CResult_CVec_SignatureZNoneZ, + /// Create a signature for the given input in a transaction spending an HTLC or commitment + /// transaction output when our counterparty broadcasts an old state. + /// + /// A justice transaction may claim multiples outputs at the same time if timelocks are + /// similar, but only a signature for the input at index `input` should be signed for here. + /// It may be called multiples time for same output(s) if a fee-bump is needed with regards + /// to an upcoming timelock expiration. + /// + /// Amount is value of the output spent by this input, committed to in the BIP 143 signature. + /// + /// per_commitment_key is revocation secret which was provided by our counterparty when they + /// revoked the state which they eventually broadcast. It's not a _local_ secret key and does + /// not allow the spending of any funds by itself (you need our local revocation_secret to do + /// so). + /// + /// htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus + /// changing the format of the witness script (which is committed to in the BIP 143 + /// signatures). + #[must_use] + 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, + /// Create a signature for a claiming transaction for a HTLC output on a remote commitment + /// transaction, either offered or received. + /// + /// Such a transaction may claim multiples offered outputs at same time if we know the + /// preimage for each when we create it, but only the input at index `input` should be + /// signed for here. It may be called multiple times for same output(s) if a fee-bump is + /// needed with regards to an upcoming timelock expiration. + /// + /// Witness_script is either a offered or received script as defined in BOLT3 for HTLC + /// outputs. + /// + /// Amount is value of the output spent by this input, committed to in the BIP 143 signature. + /// + /// Per_commitment_point is the dynamic point corresponding to the channel state + /// detected onchain. It has been generated by our counterparty and is used to derive + /// channel state keys, which are then included in the witness script and committed to in the + /// BIP 143 signature. + #[must_use] + pub sign_remote_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, + /// Create a signature for a (proposed) closing transaction. + /// + /// Note that, due to rounding, there may be one \"missing\" satoshi, and either party may have + /// chosen to forgo their output as dust. + #[must_use] + pub sign_closing_transaction: extern "C" fn (this_arg: *const c_void, closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ, + /// Signs a channel announcement message with our funding key, proving it comes from one + /// of the channel participants. + /// + /// Note that if this fails or is rejected, the channel will not be publicly announced and + /// our counterparty may (though likely will not) close the channel on us for violating the + /// protocol. + #[must_use] + pub sign_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ, + /// Set the remote channel basepoints and remote/local to_self_delay. + /// This is done immediately on incoming channels and as soon as the channel is accepted on outgoing channels. + /// + /// We bind local_to_self_delay late here for API convenience. + /// + /// Will be called before any signatures are applied. + pub on_accept: extern "C" fn (this_arg: *mut c_void, channel_points: &crate::ln::chan_utils::ChannelPublicKeys, remote_to_self_delay: u16, local_to_self_delay: u16), + pub clone: Option *mut c_void>, + pub free: Option, +} +unsafe impl Send for ChannelKeys {} +impl Clone for ChannelKeys { + fn clone(&self) -> Self { + Self { + this_arg: if let Some(f) = self.clone { (f)(self.this_arg) } else { self.this_arg }, + get_per_commitment_point: self.get_per_commitment_point.clone(), + release_commitment_secret: self.release_commitment_secret.clone(), + pubkeys: self.pubkeys.clone(), + set_pubkeys: self.set_pubkeys.clone(), + key_derivation_params: self.key_derivation_params.clone(), + sign_remote_commitment: self.sign_remote_commitment.clone(), + sign_local_commitment: self.sign_local_commitment.clone(), + sign_local_commitment_htlc_transactions: self.sign_local_commitment_htlc_transactions.clone(), + sign_justice_transaction: self.sign_justice_transaction.clone(), + sign_remote_htlc_transaction: self.sign_remote_htlc_transaction.clone(), + sign_closing_transaction: self.sign_closing_transaction.clone(), + sign_channel_announcement: self.sign_channel_announcement.clone(), + on_accept: self.on_accept.clone(), + clone: self.clone.clone(), + free: self.free.clone(), + } + } +} + +use lightning::chain::keysinterface::ChannelKeys as rustChannelKeys; +impl rustChannelKeys for ChannelKeys { + fn get_per_commitment_point(&self, idx: u64, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> bitcoin::secp256k1::key::PublicKey { + let mut ret = (self.get_per_commitment_point)(self.this_arg, idx); + ret.into_rust() + } + fn release_commitment_secret(&self, idx: u64) -> [u8; 32] { + let mut ret = (self.release_commitment_secret)(self.this_arg, idx); + ret.data + } + fn pubkeys(&self) -> &lightning::ln::chan_utils::ChannelPublicKeys { + if let Some(f) = self.set_pubkeys { + (f)(self); + } + unsafe { &*self.pubkeys.inner } + } + fn key_derivation_params(&self) -> (u64, u64) { + let mut ret = (self.key_derivation_params)(self.this_arg); + let (mut orig_ret_0, mut orig_ret_1) = ret.to_rust(); let mut local_ret = (orig_ret_0, orig_ret_1); + local_ret + } + fn sign_remote_commitment(&self, feerate_per_kw: u32, commitment_tx: &bitcoin::blockdata::transaction::Transaction, keys: &lightning::ln::chan_utils::PreCalculatedTxCreationKeys, htlcs: &[&lightning::ln::chan_utils::HTLCOutputInCommitment], _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result<(bitcoin::secp256k1::Signature, Vec), ()> { + let mut local_commitment_tx = ::bitcoin::consensus::encode::serialize(commitment_tx); + let mut local_htlcs = Vec::new(); for item in htlcs.iter() { local_htlcs.push( { crate::ln::chan_utils::HTLCOutputInCommitment { inner: unsafe { ( (&(**item) as *const _) as *mut _) }, is_owned: false } }); }; + let mut ret = (self.sign_remote_commitment)(self.this_arg, feerate_per_kw, crate::c_types::Transaction::from_slice(&local_commitment_tx), &crate::ln::chan_utils::PreCalculatedTxCreationKeys { inner: unsafe { (keys as *const _) as *mut _ }, is_owned: false }, local_htlcs.into()); + 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(ret.contents.result.take_ptr()) }).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(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_local_commitment(&self, local_commitment_tx: &lightning::ln::chan_utils::LocalCommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result { + let mut ret = (self.sign_local_commitment)(self.this_arg, &crate::ln::chan_utils::LocalCommitmentTransaction { inner: unsafe { (local_commitment_tx as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust() }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_local_commitment_htlc_transactions(&self, local_commitment_tx: &lightning::ln::chan_utils::LocalCommitmentTransaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result>, ()> { + let mut ret = (self.sign_local_commitment_htlc_transactions)(self.this_arg, &crate::ln::chan_utils::LocalCommitmentTransaction { inner: unsafe { (local_commitment_tx as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { let mut local_ret_0 = Vec::new(); for mut item in (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust().drain(..) { local_ret_0.push( { let mut local_ret_0_0 = if item.is_null() { None } else { Some( { item.into_rust() }) }; local_ret_0_0 }); }; local_ret_0 }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_justice_transaction(&self, justice_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_key: &bitcoin::secp256k1::key::SecretKey, htlc: &Option, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result { + let mut local_justice_tx = ::bitcoin::consensus::encode::serialize(justice_tx); + 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 }; + let mut ret = (self.sign_justice_transaction)(self.this_arg, crate::c_types::Transaction::from_slice(&local_justice_tx), input, amount, per_commitment_key.as_ref(), local_htlc); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust() }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_remote_htlc_transaction(&self, htlc_tx: &bitcoin::blockdata::transaction::Transaction, input: usize, amount: u64, per_commitment_point: &bitcoin::secp256k1::key::PublicKey, htlc: &lightning::ln::chan_utils::HTLCOutputInCommitment, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result { + let mut local_htlc_tx = ::bitcoin::consensus::encode::serialize(htlc_tx); + let mut ret = (self.sign_remote_htlc_transaction)(self.this_arg, crate::c_types::Transaction::from_slice(&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 }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust() }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_closing_transaction(&self, closing_tx: &bitcoin::blockdata::transaction::Transaction, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result { + let mut local_closing_tx = ::bitcoin::consensus::encode::serialize(closing_tx); + let mut ret = (self.sign_closing_transaction)(self.this_arg, crate::c_types::Transaction::from_slice(&local_closing_tx)); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust() }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn sign_channel_announcement(&self, msg: &lightning::ln::msgs::UnsignedChannelAnnouncement, _secp_ctx: &bitcoin::secp256k1::Secp256k1) -> Result { + let mut ret = (self.sign_channel_announcement)(self.this_arg, &crate::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }).into_rust() }), false => Err( { () /*(*unsafe { Box::from_raw(ret.contents.err.take_ptr()) })*/ })}; + local_ret + } + fn on_accept(&mut self, channel_points: &lightning::ln::chan_utils::ChannelPublicKeys, remote_to_self_delay: u16, local_to_self_delay: u16) { + (self.on_accept)(self.this_arg, &crate::ln::chan_utils::ChannelPublicKeys { inner: unsafe { (channel_points as *const _) as *mut _ }, is_owned: false }, remote_to_self_delay, local_to_self_delay) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for ChannelKeys { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn ChannelKeys_free(this_ptr: ChannelKeys) { } +impl Drop for ChannelKeys { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// A trait to describe an object which can get user secrets and key material. +#[repr(C)] +pub struct KeysInterface { + pub this_arg: *mut c_void, + /// Get node secret key (aka node_id or network_key) + #[must_use] + pub get_node_secret: extern "C" fn (this_arg: *const c_void) -> crate::c_types::SecretKey, + /// Get destination redeemScript to encumber static protocol exit points. + #[must_use] + pub get_destination_script: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z, + /// Get shutdown_pubkey to use as PublicKey at channel closure + #[must_use] + pub get_shutdown_pubkey: extern "C" fn (this_arg: *const c_void) -> crate::c_types::PublicKey, + /// Get a new set of ChannelKeys for per-channel secrets. These MUST be unique even if you + /// restarted with some stale data! + #[must_use] + pub get_channel_keys: extern "C" fn (this_arg: *const c_void, inbound: bool, channel_value_satoshis: u64) -> crate::chain::keysinterface::ChannelKeys, + /// Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting + /// onion packets and for temporary channel IDs. There is no requirement that these be + /// persisted anywhere, though they must be unique across restarts. + #[must_use] + pub get_secure_random_bytes: extern "C" fn (this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes, + pub free: Option, +} +unsafe impl Send for KeysInterface {} +unsafe impl Sync for KeysInterface {} + +use lightning::chain::keysinterface::KeysInterface as rustKeysInterface; +impl rustKeysInterface for KeysInterface { + type ChanKeySigner = crate::chain::keysinterface::ChannelKeys; + fn get_node_secret(&self) -> bitcoin::secp256k1::key::SecretKey { + let mut ret = (self.get_node_secret)(self.this_arg); + ret.into_rust() + } + fn get_destination_script(&self) -> bitcoin::blockdata::script::Script { + let mut ret = (self.get_destination_script)(self.this_arg); + ::bitcoin::blockdata::script::Script::from(ret.into_rust()) + } + fn get_shutdown_pubkey(&self) -> bitcoin::secp256k1::key::PublicKey { + let mut ret = (self.get_shutdown_pubkey)(self.this_arg); + ret.into_rust() + } + fn get_channel_keys(&self, inbound: bool, channel_value_satoshis: u64) -> Self::ChanKeySigner { + let mut ret = (self.get_channel_keys)(self.this_arg, inbound, channel_value_satoshis); + ret + } + fn get_secure_random_bytes(&self) -> [u8; 32] { + let mut ret = (self.get_secure_random_bytes)(self.this_arg); + ret.data + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for KeysInterface { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn KeysInterface_free(this_ptr: KeysInterface) { } +impl Drop for KeysInterface { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} + +use lightning::chain::keysinterface::InMemoryChannelKeys as nativeInMemoryChannelKeysImport; +type nativeInMemoryChannelKeys = nativeInMemoryChannelKeysImport; + +/// A simple implementation of ChannelKeys that just keeps the private keys in memory. +#[must_use] +#[repr(C)] +pub struct InMemoryChannelKeys { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeInMemoryChannelKeys, + pub is_owned: bool, +} + +impl Drop for InMemoryChannelKeys { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_free(this_ptr: InMemoryChannelKeys) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn InMemoryChannelKeys_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInMemoryChannelKeys); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl InMemoryChannelKeys { + pub(crate) fn take_ptr(mut self) -> *mut nativeInMemoryChannelKeys { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for InMemoryChannelKeys { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn InMemoryChannelKeys_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInMemoryChannelKeys)).clone() })) as *mut c_void +} +/// Private key of anchor tx +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_funding_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_key; + (*inner_val).as_ref() +} +/// Private key of anchor tx +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_funding_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) { + unsafe { &mut *this_ptr.inner }.funding_key = val.into_rust(); +} +/// Local secret key for blinded revocation pubkey +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_revocation_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_base_key; + (*inner_val).as_ref() +} +/// Local secret key for blinded revocation pubkey +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_revocation_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) { + unsafe { &mut *this_ptr.inner }.revocation_base_key = val.into_rust(); +} +/// Local secret key used for our balance in remote-broadcasted commitment transactions +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_payment_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_key; + (*inner_val).as_ref() +} +/// Local secret key used for our balance in remote-broadcasted commitment transactions +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_payment_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) { + unsafe { &mut *this_ptr.inner }.payment_key = val.into_rust(); +} +/// Local secret key used in HTLC tx +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_base_key; + (*inner_val).as_ref() +} +/// Local secret key used in HTLC tx +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) { + unsafe { &mut *this_ptr.inner }.delayed_payment_base_key = val.into_rust(); +} +/// Local htlc secret key used in commitment tx htlc outputs +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_htlc_base_key(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_base_key; + (*inner_val).as_ref() +} +/// Local htlc secret key used in commitment tx htlc outputs +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_htlc_base_key(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::SecretKey) { + unsafe { &mut *this_ptr.inner }.htlc_base_key = val.into_rust(); +} +/// Commitment seed +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_get_commitment_seed(this_ptr: &InMemoryChannelKeys) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_seed; + &(*inner_val) +} +/// Commitment seed +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_set_commitment_seed(this_ptr: &mut InMemoryChannelKeys, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.commitment_seed = val.data; +} +/// Create a new InMemoryChannelKeys +#[must_use] +#[no_mangle] +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 { + 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); + 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); + crate::chain::keysinterface::InMemoryChannelKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Remote pubkeys. +/// Will panic if on_accept wasn't called. +#[must_use] +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_remote_pubkeys(this_arg: &InMemoryChannelKeys) -> crate::ln::chan_utils::ChannelPublicKeys { + let mut ret = unsafe { &*this_arg.inner }.remote_pubkeys(); + crate::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false } +} + +/// The to_self_delay value specified by our counterparty and applied on locally-broadcastable +/// transactions, ie the amount of time that we have to wait to recover our funds if we +/// broadcast a transaction. You'll likely want to pass this to the +/// ln::chan_utils::build*_transaction functions when signing local transactions. +/// Will panic if on_accept wasn't called. +#[must_use] +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_remote_to_self_delay(this_arg: &InMemoryChannelKeys) -> u16 { + let mut ret = unsafe { &*this_arg.inner }.remote_to_self_delay(); + ret +} + +/// The to_self_delay value specified by us and applied on transactions broadcastable +/// by our counterparty, ie the amount of time that they have to wait to recover their funds +/// if they broadcast a transaction. +/// Will panic if on_accept wasn't called. +#[must_use] +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_local_to_self_delay(this_arg: &InMemoryChannelKeys) -> u16 { + let mut ret = unsafe { &*this_arg.inner }.local_to_self_delay(); + ret +} + +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_as_ChannelKeys(this_arg: *const InMemoryChannelKeys) -> crate::chain::keysinterface::ChannelKeys { + crate::chain::keysinterface::ChannelKeys { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + get_per_commitment_point: InMemoryChannelKeys_ChannelKeys_get_per_commitment_point, + release_commitment_secret: InMemoryChannelKeys_ChannelKeys_release_commitment_secret, + + pubkeys: crate::ln::chan_utils::ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true }, + set_pubkeys: Some(InMemoryChannelKeys_ChannelKeys_set_pubkeys), + key_derivation_params: InMemoryChannelKeys_ChannelKeys_key_derivation_params, + sign_remote_commitment: InMemoryChannelKeys_ChannelKeys_sign_remote_commitment, + sign_local_commitment: InMemoryChannelKeys_ChannelKeys_sign_local_commitment, + sign_local_commitment_htlc_transactions: InMemoryChannelKeys_ChannelKeys_sign_local_commitment_htlc_transactions, + sign_justice_transaction: InMemoryChannelKeys_ChannelKeys_sign_justice_transaction, + sign_remote_htlc_transaction: InMemoryChannelKeys_ChannelKeys_sign_remote_htlc_transaction, + sign_closing_transaction: InMemoryChannelKeys_ChannelKeys_sign_closing_transaction, + sign_channel_announcement: InMemoryChannelKeys_ChannelKeys_sign_channel_announcement, + on_accept: InMemoryChannelKeys_ChannelKeys_on_accept, + clone: Some(InMemoryChannelKeys_clone_void), + } +} +use lightning::chain::keysinterface::ChannelKeys as ChannelKeysTraitImport; +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_get_per_commitment_point(this_arg: *const c_void, mut idx: u64) -> crate::c_types::PublicKey { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.get_per_commitment_point(idx, &bitcoin::secp256k1::Secp256k1::new()); + crate::c_types::PublicKey::from_rust(&ret) +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_release_commitment_secret(this_arg: *const c_void, mut idx: u64) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.release_commitment_secret(idx); + crate::c_types::ThirtyTwoBytes { data: ret } +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_pubkeys(this_arg: *const c_void) -> crate::ln::chan_utils::ChannelPublicKeys { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.pubkeys(); + crate::ln::chan_utils::ChannelPublicKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false } +} +extern "C" fn InMemoryChannelKeys_ChannelKeys_set_pubkeys(trait_self_arg: &ChannelKeys) { + // This is a bit race-y in the general case, but for our specific use-cases today, we're safe + // Specifically, we must ensure that the first time we're called it can never be in parallel + if trait_self_arg.pubkeys.inner.is_null() { + unsafe { &mut *(trait_self_arg as *const ChannelKeys as *mut ChannelKeys) }.pubkeys = InMemoryChannelKeys_ChannelKeys_pubkeys(trait_self_arg.this_arg); + } +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_key_derivation_params(this_arg: *const c_void) -> crate::c_types::derived::C2Tuple_u64u64Z { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.key_derivation_params(); + let (mut orig_ret_0, mut orig_ret_1) = ret; let mut local_ret = (orig_ret_0, orig_ret_1).into(); + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_remote_commitment(this_arg: *const c_void, mut feerate_per_kw: u32, commitment_tx: crate::c_types::Transaction, pre_keys: &crate::ln::chan_utils::PreCalculatedTxCreationKeys, mut htlcs: crate::c_types::derived::CVec_HTLCOutputInCommitmentZ) -> crate::c_types::derived::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ { + let mut local_htlcs = Vec::new(); for mut item in htlcs.as_slice().iter() { local_htlcs.push( { unsafe { &*item.inner } }); }; + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_remote_commitment(feerate_per_kw, &commitment_tx.into_bitcoin(), unsafe { &*pre_keys.inner }, &local_htlcs[..], &bitcoin::secp256k1::Secp256k1::new()); + 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*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_local_commitment(this_arg: *const c_void, local_commitment_tx: &crate::ln::chan_utils::LocalCommitmentTransaction) -> crate::c_types::derived::CResult_SignatureNoneZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_local_commitment(unsafe { &*local_commitment_tx.inner }, &bitcoin::secp256k1::Secp256k1::new()); + 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*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_local_commitment_htlc_transactions(this_arg: *const c_void, local_commitment_tx: &crate::ln::chan_utils::LocalCommitmentTransaction) -> crate::c_types::derived::CResult_CVec_SignatureZNoneZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_local_commitment_htlc_transactions(unsafe { &*local_commitment_tx.inner }, &bitcoin::secp256k1::Secp256k1::new()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_ret_0 = Vec::new(); for item in o.drain(..) { local_ret_0.push( { let mut local_ret_0_0 = if item.is_none() { crate::c_types::Signature::null() } else { { crate::c_types::Signature::from_rust(&(item.unwrap())) } }; local_ret_0_0 }); }; local_ret_0.into() }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_justice_transaction(this_arg: *const c_void, 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 { + let mut local_htlc = if htlc.inner.is_null() { None } else { Some((* { unsafe { &*htlc.inner } }).clone()) }; + 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()); + 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*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_remote_htlc_transaction(this_arg: *const c_void, htlc_tx: crate::c_types::Transaction, mut input: usize, mut amount: u64, per_commitment_point: crate::c_types::PublicKey, htlc: &crate::ln::chan_utils::HTLCOutputInCommitment) -> crate::c_types::derived::CResult_SignatureNoneZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_remote_htlc_transaction(&htlc_tx.into_bitcoin(), input, amount, &per_commitment_point.into_rust(), unsafe { &*htlc.inner }, &bitcoin::secp256k1::Secp256k1::new()); + 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*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_closing_transaction(this_arg: *const c_void, closing_tx: crate::c_types::Transaction) -> crate::c_types::derived::CResult_SignatureNoneZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_closing_transaction(&closing_tx.into_bitcoin(), &bitcoin::secp256k1::Secp256k1::new()); + 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*/ }) }; + local_ret +} +#[must_use] +extern "C" fn InMemoryChannelKeys_ChannelKeys_sign_channel_announcement(this_arg: *const c_void, msg: &crate::ln::msgs::UnsignedChannelAnnouncement) -> crate::c_types::derived::CResult_SignatureNoneZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.sign_channel_announcement(unsafe { &*msg.inner }, &bitcoin::secp256k1::Secp256k1::new()); + 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*/ }) }; + local_ret +} +extern "C" fn InMemoryChannelKeys_ChannelKeys_on_accept(this_arg: *mut c_void, channel_pubkeys: &crate::ln::chan_utils::ChannelPublicKeys, mut remote_to_self_delay: u16, mut local_to_self_delay: u16) { + unsafe { &mut *(this_arg as *mut nativeInMemoryChannelKeys) }.on_accept(unsafe { &*channel_pubkeys.inner }, remote_to_self_delay, local_to_self_delay) +} + +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_write(obj: *const InMemoryChannelKeys) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn InMemoryChannelKeys_read(ser: crate::c_types::u8slice) -> InMemoryChannelKeys { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + InMemoryChannelKeys { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + InMemoryChannelKeys { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::chain::keysinterface::KeysManager as nativeKeysManagerImport; +type nativeKeysManager = nativeKeysManagerImport; + +/// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key +/// and derives keys from that. +/// +/// Your node_id is seed/0' +/// ChannelMonitor closes may use seed/1' +/// Cooperative closes may use seed/2' +/// The two close keys may be needed to claim on-chain funds! +#[must_use] +#[repr(C)] +pub struct KeysManager { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeKeysManager, + pub is_owned: bool, +} + +impl Drop for KeysManager { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn KeysManager_free(this_ptr: KeysManager) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn KeysManager_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeKeysManager); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl KeysManager { + pub(crate) fn take_ptr(mut self) -> *mut nativeKeysManager { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your +/// CSRNG is busted) this may panic (but more importantly, you will possibly lose funds). +/// starting_time isn't strictly required to actually be a time, but it must absolutely, +/// without a doubt, be unique to this instance. ie if you start multiple times with the same +/// seed, starting_time must be unique to each run. Thus, the easiest way to achieve this is to +/// simply use the current time (with very high precision). +/// +/// The seed MUST be backed up safely prior to use so that the keys can be re-created, however, +/// obviously, starting_time should be unique every time you reload the library - it is only +/// used to generate new ephemeral key data (which will be stored by the individual channel if +/// necessary). +/// +/// Note that the seed is required to recover certain on-chain funds independent of +/// ChannelMonitor data, though a current copy of ChannelMonitor data is also required for any +/// channel, and some on-chain during-closing funds. +/// +/// Note that until the 0.1 release there is no guarantee of backward compatibility between +/// versions. Once the library is more fully supported, the docs will be updated to include a +/// detailed description of the guarantee. +#[must_use] +#[no_mangle] +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 { + let mut ret = lightning::chain::keysinterface::KeysManager::new(unsafe { &*seed}, network.into_bitcoin(), starting_time_secs, starting_time_nanos); + KeysManager { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Derive an old set of ChannelKeys for per-channel secrets based on a key derivation +/// parameters. +/// Key derivation parameters are accessible through a per-channel secrets +/// ChannelKeys::key_derivation_params and is provided inside DynamicOuputP2WSH in case of +/// onchain output detection for which a corresponding delayed_payment_key must be derived. +#[must_use] +#[no_mangle] +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 { + let mut ret = unsafe { &*this_arg.inner }.derive_channel_keys(channel_value_satoshis, params_1, params_2); + crate::chain::keysinterface::InMemoryChannelKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +#[no_mangle] +pub extern "C" fn KeysManager_as_KeysInterface(this_arg: *const KeysManager) -> crate::chain::keysinterface::KeysInterface { + crate::chain::keysinterface::KeysInterface { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + get_node_secret: KeysManager_KeysInterface_get_node_secret, + get_destination_script: KeysManager_KeysInterface_get_destination_script, + get_shutdown_pubkey: KeysManager_KeysInterface_get_shutdown_pubkey, + get_channel_keys: KeysManager_KeysInterface_get_channel_keys, + get_secure_random_bytes: KeysManager_KeysInterface_get_secure_random_bytes, + } +} +use lightning::chain::keysinterface::KeysInterface as KeysInterfaceTraitImport; +#[must_use] +extern "C" fn KeysManager_KeysInterface_get_node_secret(this_arg: *const c_void) -> crate::c_types::SecretKey { + let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_node_secret(); + crate::c_types::SecretKey::from_rust(ret) +} +#[must_use] +extern "C" fn KeysManager_KeysInterface_get_destination_script(this_arg: *const c_void) -> crate::c_types::derived::CVec_u8Z { + let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_destination_script(); + ret.into_bytes().into() +} +#[must_use] +extern "C" fn KeysManager_KeysInterface_get_shutdown_pubkey(this_arg: *const c_void) -> crate::c_types::PublicKey { + let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_shutdown_pubkey(); + crate::c_types::PublicKey::from_rust(&ret) +} +#[must_use] +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 { + let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_channel_keys(_inbound, channel_value_satoshis); + let mut rust_obj = InMemoryChannelKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true }; + let mut ret = InMemoryChannelKeys_as_ChannelKeys(&rust_obj); + // We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn + rust_obj.inner = std::ptr::null_mut(); + ret.free = Some(InMemoryChannelKeys_free_void); + ret + +} +#[must_use] +extern "C" fn KeysManager_KeysInterface_get_secure_random_bytes(this_arg: *const c_void) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &mut *(this_arg as *mut nativeKeysManager) }.get_secure_random_bytes(); + crate::c_types::ThirtyTwoBytes { data: ret } +} + diff --git a/lightning-c-bindings/src/chain/mod.rs b/lightning-c-bindings/src/chain/mod.rs new file mode 100644 index 000000000..44ce4c142 --- /dev/null +++ b/lightning-c-bindings/src/chain/mod.rs @@ -0,0 +1,9 @@ +//! Structs and traits which allow other parts of rust-lightning to interact with the blockchain. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +pub mod chaininterface; +pub mod transaction; +pub mod keysinterface; diff --git a/lightning-c-bindings/src/chain/transaction.rs b/lightning-c-bindings/src/chain/transaction.rs new file mode 100644 index 000000000..39236768d --- /dev/null +++ b/lightning-c-bindings/src/chain/transaction.rs @@ -0,0 +1,110 @@ +//! Contains simple structs describing parts of transactions on the chain. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::chain::transaction::OutPoint as nativeOutPointImport; +type nativeOutPoint = nativeOutPointImport; + +/// A reference to a transaction output. +/// +/// Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32 +/// due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way. +#[must_use] +#[repr(C)] +pub struct OutPoint { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeOutPoint, + pub is_owned: bool, +} + +impl Drop for OutPoint { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn OutPoint_free(this_ptr: OutPoint) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn OutPoint_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeOutPoint); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl OutPoint { + pub(crate) fn take_ptr(mut self) -> *mut nativeOutPoint { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for OutPoint { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn OutPoint_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOutPoint)).clone() })) as *mut c_void +} +/// The referenced transaction's txid. +#[no_mangle] +pub extern "C" fn OutPoint_get_txid(this_ptr: &OutPoint) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.txid; + (*inner_val).as_inner() +} +/// The referenced transaction's txid. +#[no_mangle] +pub extern "C" fn OutPoint_set_txid(this_ptr: &mut OutPoint, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.txid = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap(); +} +/// The index of the referenced output in its transaction's vout. +#[no_mangle] +pub extern "C" fn OutPoint_get_index(this_ptr: &OutPoint) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.index; + (*inner_val) +} +/// The index of the referenced output in its transaction's vout. +#[no_mangle] +pub extern "C" fn OutPoint_set_index(this_ptr: &mut OutPoint, mut val: u16) { + unsafe { &mut *this_ptr.inner }.index = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn OutPoint_new(mut txid_arg: crate::c_types::ThirtyTwoBytes, mut index_arg: u16) -> OutPoint { + OutPoint { inner: Box::into_raw(Box::new(nativeOutPoint { + txid: ::bitcoin::hash_types::Txid::from_slice(&txid_arg.data[..]).unwrap(), + index: index_arg, + })), is_owned: true } +} +/// Convert an `OutPoint` to a lightning channel id. +#[must_use] +#[no_mangle] +pub extern "C" fn OutPoint_to_channel_id(this_arg: &OutPoint) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &*this_arg.inner }.to_channel_id(); + crate::c_types::ThirtyTwoBytes { data: ret } +} + +#[no_mangle] +pub extern "C" fn OutPoint_write(obj: *const OutPoint) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn OutPoint_read(ser: crate::c_types::u8slice) -> OutPoint { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + OutPoint { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + OutPoint { inner: std::ptr::null_mut(), is_owned: true } + } +} diff --git a/lightning-c-bindings/src/lib.rs b/lightning-c-bindings/src/lib.rs new file mode 100644 index 000000000..89dfc0903 --- /dev/null +++ b/lightning-c-bindings/src/lib.rs @@ -0,0 +1,24 @@ +//!lightning +//! Rust-Lightning, not Rusty's Lightning! +//! +//! A full-featured but also flexible lightning implementation, in library form. This allows the +//! user (you) to decide how they wish to use it instead of being a fully self-contained daemon. +//! This means there is no built-in threading/execution environment and it's up to the user to +//! figure out how best to make networking happen/timers fire/things get written to disk/keys get +//! generated/etc. This makes it a good candidate for tight integration into an existing wallet +//! instead of having a rather-separate lightning appendage to a wallet. +#![allow(unknown_lints)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(unused_imports)] +#![allow(unused_variables)] +#![allow(unused_mut)] +#![allow(unused_parens)] +#![allow(unused_unsafe)] +#![allow(unused_braces)] +mod c_types; +mod bitcoin; +pub mod util; +pub mod chain; +pub mod ln; +pub mod routing; diff --git a/lightning-c-bindings/src/ln/chan_utils.rs b/lightning-c-bindings/src/ln/chan_utils.rs new file mode 100644 index 000000000..df9094a51 --- /dev/null +++ b/lightning-c-bindings/src/ln/chan_utils.rs @@ -0,0 +1,745 @@ +//! Various utilities for building scripts and deriving keys related to channels. These are +//! largely of interest for those implementing chain::keysinterface::ChannelKeys message signing +//! by hand. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// Build the commitment secret from the seed and the commitment number +#[no_mangle] +pub extern "C" fn build_commitment_secret(commitment_seed: *const [u8; 32], mut idx: u64) -> crate::c_types::ThirtyTwoBytes { + let mut ret = lightning::ln::chan_utils::build_commitment_secret(unsafe { &*commitment_seed}, idx); + crate::c_types::ThirtyTwoBytes { data: ret } +} + +/// Derives a per-commitment-transaction private key (eg an htlc key or delayed_payment key) +/// from the base secret and the per_commitment_point. +/// +/// Note that this is infallible iff we trust that at least one of the two input keys are randomly +/// generated (ie our own). +#[no_mangle] +pub extern "C" fn derive_private_key(per_commitment_point: crate::c_types::PublicKey, base_secret: *const [u8; 32]) -> crate::c_types::derived::CResult_SecretKeySecpErrorZ { + let mut ret = lightning::ln::chan_utils::derive_private_key(&bitcoin::secp256k1::Secp256k1::new(), &per_commitment_point.into_rust(), &::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *base_secret}[..]).unwrap()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::SecretKey::from_rust(o) }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }) }; + local_ret +} + +/// Derives a per-commitment-transaction public key (eg an htlc key or a delayed_payment key) +/// from the base point and the per_commitment_key. This is the public equivalent of +/// derive_private_key - using only public keys to derive a public key instead of private keys. +/// +/// Note that this is infallible iff we trust that at least one of the two input keys are randomly +/// generated (ie our own). +#[no_mangle] +pub extern "C" fn derive_public_key(per_commitment_point: crate::c_types::PublicKey, base_point: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_PublicKeySecpErrorZ { + let mut ret = lightning::ln::chan_utils::derive_public_key(&bitcoin::secp256k1::Secp256k1::new(), &per_commitment_point.into_rust(), &base_point.into_rust()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::PublicKey::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }) }; + local_ret +} + +/// Derives a per-commitment-transaction revocation key from its constituent parts. +/// +/// Note that this is infallible iff we trust that at least one of the two input keys are randomly +/// generated (ie our own). +#[no_mangle] +pub extern "C" fn derive_private_revocation_key(per_commitment_secret: *const [u8; 32], revocation_base_secret: *const [u8; 32]) -> crate::c_types::derived::CResult_SecretKeySecpErrorZ { + let mut ret = lightning::ln::chan_utils::derive_private_revocation_key(&bitcoin::secp256k1::Secp256k1::new(), &::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *per_commitment_secret}[..]).unwrap(), &::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *revocation_base_secret}[..]).unwrap()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::SecretKey::from_rust(o) }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }) }; + local_ret +} + +/// Derives a per-commitment-transaction revocation public key from its constituent parts. This is +/// the public equivalend of derive_private_revocation_key - using only public keys to derive a +/// public key instead of private keys. +/// +/// Note that this is infallible iff we trust that at least one of the two input keys are randomly +/// generated (ie our own). +#[no_mangle] +pub extern "C" fn derive_public_revocation_key(per_commitment_point: crate::c_types::PublicKey, revocation_base_point: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_PublicKeySecpErrorZ { + let mut ret = lightning::ln::chan_utils::derive_public_revocation_key(&bitcoin::secp256k1::Secp256k1::new(), &per_commitment_point.into_rust(), &revocation_base_point.into_rust()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::PublicKey::from_rust(&o) }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }) }; + local_ret +} + + +use lightning::ln::chan_utils::TxCreationKeys as nativeTxCreationKeysImport; +type nativeTxCreationKeys = nativeTxCreationKeysImport; + +/// The set of public keys which are used in the creation of one commitment transaction. +/// These are derived from the channel base keys and per-commitment data. +/// +/// These keys are assumed to be good, either because the code derived them from +/// channel basepoints via the new function, or they were obtained via +/// PreCalculatedTxCreationKeys.trust_key_derivation because we trusted the source of the +/// pre-calculated keys. +#[must_use] +#[repr(C)] +pub struct TxCreationKeys { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeTxCreationKeys, + pub is_owned: bool, +} + +impl Drop for TxCreationKeys { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn TxCreationKeys_free(this_ptr: TxCreationKeys) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn TxCreationKeys_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeTxCreationKeys); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl TxCreationKeys { + pub(crate) fn take_ptr(mut self) -> *mut nativeTxCreationKeys { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for TxCreationKeys { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn TxCreationKeys_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeTxCreationKeys)).clone() })) as *mut c_void +} +/// The per-commitment public key which was used to derive the other keys. +#[no_mangle] +pub extern "C" fn TxCreationKeys_get_per_commitment_point(this_ptr: &TxCreationKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The per-commitment public key which was used to derive the other keys. +#[no_mangle] +pub extern "C" fn TxCreationKeys_set_per_commitment_point(this_ptr: &mut TxCreationKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.per_commitment_point = val.into_rust(); +} +/// The revocation key which is used to allow the owner of the commitment transaction to +/// provide their counterparty the ability to punish them if they broadcast an old state. +#[no_mangle] +pub extern "C" fn TxCreationKeys_get_revocation_key(this_ptr: &TxCreationKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_key; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The revocation key which is used to allow the owner of the commitment transaction to +/// provide their counterparty the ability to punish them if they broadcast an old state. +#[no_mangle] +pub extern "C" fn TxCreationKeys_set_revocation_key(this_ptr: &mut TxCreationKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.revocation_key = val.into_rust(); +} +/// A's HTLC Key +#[no_mangle] +pub extern "C" fn TxCreationKeys_get_a_htlc_key(this_ptr: &TxCreationKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.a_htlc_key; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// A's HTLC Key +#[no_mangle] +pub extern "C" fn TxCreationKeys_set_a_htlc_key(this_ptr: &mut TxCreationKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.a_htlc_key = val.into_rust(); +} +/// B's HTLC Key +#[no_mangle] +pub extern "C" fn TxCreationKeys_get_b_htlc_key(this_ptr: &TxCreationKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.b_htlc_key; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// B's HTLC Key +#[no_mangle] +pub extern "C" fn TxCreationKeys_set_b_htlc_key(this_ptr: &mut TxCreationKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.b_htlc_key = val.into_rust(); +} +/// A's Payment Key (which isn't allowed to be spent from for some delay) +#[no_mangle] +pub extern "C" fn TxCreationKeys_get_a_delayed_payment_key(this_ptr: &TxCreationKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.a_delayed_payment_key; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// A's Payment Key (which isn't allowed to be spent from for some delay) +#[no_mangle] +pub extern "C" fn TxCreationKeys_set_a_delayed_payment_key(this_ptr: &mut TxCreationKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.a_delayed_payment_key = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn TxCreationKeys_new(mut per_commitment_point_arg: crate::c_types::PublicKey, mut revocation_key_arg: crate::c_types::PublicKey, mut a_htlc_key_arg: crate::c_types::PublicKey, mut b_htlc_key_arg: crate::c_types::PublicKey, mut a_delayed_payment_key_arg: crate::c_types::PublicKey) -> TxCreationKeys { + TxCreationKeys { inner: Box::into_raw(Box::new(nativeTxCreationKeys { + per_commitment_point: per_commitment_point_arg.into_rust(), + revocation_key: revocation_key_arg.into_rust(), + a_htlc_key: a_htlc_key_arg.into_rust(), + b_htlc_key: b_htlc_key_arg.into_rust(), + a_delayed_payment_key: a_delayed_payment_key_arg.into_rust(), + })), is_owned: true } +} +#[no_mangle] +pub extern "C" fn TxCreationKeys_write(obj: *const TxCreationKeys) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn TxCreationKeys_read(ser: crate::c_types::u8slice) -> TxCreationKeys { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + TxCreationKeys { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + TxCreationKeys { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::ln::chan_utils::PreCalculatedTxCreationKeys as nativePreCalculatedTxCreationKeysImport; +type nativePreCalculatedTxCreationKeys = nativePreCalculatedTxCreationKeysImport; + +/// The per-commitment point and a set of pre-calculated public keys used for transaction creation +/// in the signer. +/// The pre-calculated keys are an optimization, because ChannelKeys has enough +/// information to re-derive them. +#[must_use] +#[repr(C)] +pub struct PreCalculatedTxCreationKeys { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePreCalculatedTxCreationKeys, + pub is_owned: bool, +} + +impl Drop for PreCalculatedTxCreationKeys { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn PreCalculatedTxCreationKeys_free(this_ptr: PreCalculatedTxCreationKeys) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn PreCalculatedTxCreationKeys_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePreCalculatedTxCreationKeys); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl PreCalculatedTxCreationKeys { + pub(crate) fn take_ptr(mut self) -> *mut nativePreCalculatedTxCreationKeys { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Create a new PreCalculatedTxCreationKeys from TxCreationKeys +#[must_use] +#[no_mangle] +pub extern "C" fn PreCalculatedTxCreationKeys_new(mut keys: crate::ln::chan_utils::TxCreationKeys) -> PreCalculatedTxCreationKeys { + let mut ret = lightning::ln::chan_utils::PreCalculatedTxCreationKeys::new(*unsafe { Box::from_raw(keys.take_ptr()) }); + PreCalculatedTxCreationKeys { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// The pre-calculated transaction creation public keys. +/// An external validating signer should not trust these keys. +#[must_use] +#[no_mangle] +pub extern "C" fn PreCalculatedTxCreationKeys_trust_key_derivation(this_arg: &PreCalculatedTxCreationKeys) -> crate::ln::chan_utils::TxCreationKeys { + let mut ret = unsafe { &*this_arg.inner }.trust_key_derivation(); + crate::ln::chan_utils::TxCreationKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false } +} + +/// The transaction per-commitment point +#[must_use] +#[no_mangle] +pub extern "C" fn PreCalculatedTxCreationKeys_per_commitment_point(this_arg: &PreCalculatedTxCreationKeys) -> crate::c_types::PublicKey { + let mut ret = unsafe { &*this_arg.inner }.per_commitment_point(); + crate::c_types::PublicKey::from_rust(&*ret) +} + + +use lightning::ln::chan_utils::ChannelPublicKeys as nativeChannelPublicKeysImport; +type nativeChannelPublicKeys = nativeChannelPublicKeysImport; + +/// One counterparty's public keys which do not change over the life of a channel. +#[must_use] +#[repr(C)] +pub struct ChannelPublicKeys { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelPublicKeys, + pub is_owned: bool, +} + +impl Drop for ChannelPublicKeys { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_free(this_ptr: ChannelPublicKeys) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelPublicKeys_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelPublicKeys); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelPublicKeys { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelPublicKeys { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelPublicKeys { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelPublicKeys_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelPublicKeys)).clone() })) as *mut c_void +} +/// The public key which is used to sign all commitment transactions, as it appears in the +/// on-chain channel lock-in 2-of-2 multisig output. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_get_funding_pubkey(this_ptr: &ChannelPublicKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_pubkey; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The public key which is used to sign all commitment transactions, as it appears in the +/// on-chain channel lock-in 2-of-2 multisig output. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_set_funding_pubkey(this_ptr: &mut ChannelPublicKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.funding_pubkey = val.into_rust(); +} +/// The base point which is used (with derive_public_revocation_key) to derive per-commitment +/// revocation keys. This is combined with the per-commitment-secret generated by the +/// counterparty to create a secret which the counterparty can reveal to revoke previous +/// states. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_get_revocation_basepoint(this_ptr: &ChannelPublicKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The base point which is used (with derive_public_revocation_key) to derive per-commitment +/// revocation keys. This is combined with the per-commitment-secret generated by the +/// counterparty to create a secret which the counterparty can reveal to revoke previous +/// states. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_set_revocation_basepoint(this_ptr: &mut ChannelPublicKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.revocation_basepoint = val.into_rust(); +} +/// The public key which receives our immediately spendable primary channel balance in +/// remote-broadcasted commitment transactions. This key is static across every commitment +/// transaction. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_get_payment_point(this_ptr: &ChannelPublicKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The public key which receives our immediately spendable primary channel balance in +/// remote-broadcasted commitment transactions. This key is static across every commitment +/// transaction. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_set_payment_point(this_ptr: &mut ChannelPublicKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.payment_point = val.into_rust(); +} +/// The base point which is used (with derive_public_key) to derive a per-commitment payment +/// public key which receives non-HTLC-encumbered funds which are only available for spending +/// after some delay (or can be claimed via the revocation path). +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: &ChannelPublicKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The base point which is used (with derive_public_key) to derive a per-commitment payment +/// public key which receives non-HTLC-encumbered funds which are only available for spending +/// after some delay (or can be claimed via the revocation path). +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: &mut ChannelPublicKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint = val.into_rust(); +} +/// The base point which is used (with derive_public_key) to derive a per-commitment public key +/// which is used to encumber HTLC-in-flight outputs. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_get_htlc_basepoint(this_ptr: &ChannelPublicKeys) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The base point which is used (with derive_public_key) to derive a per-commitment public key +/// which is used to encumber HTLC-in-flight outputs. +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_set_htlc_basepoint(this_ptr: &mut ChannelPublicKeys, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.htlc_basepoint = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_new(mut funding_pubkey_arg: crate::c_types::PublicKey, mut revocation_basepoint_arg: crate::c_types::PublicKey, mut payment_point_arg: crate::c_types::PublicKey, mut delayed_payment_basepoint_arg: crate::c_types::PublicKey, mut htlc_basepoint_arg: crate::c_types::PublicKey) -> ChannelPublicKeys { + ChannelPublicKeys { inner: Box::into_raw(Box::new(nativeChannelPublicKeys { + funding_pubkey: funding_pubkey_arg.into_rust(), + revocation_basepoint: revocation_basepoint_arg.into_rust(), + payment_point: payment_point_arg.into_rust(), + delayed_payment_basepoint: delayed_payment_basepoint_arg.into_rust(), + htlc_basepoint: htlc_basepoint_arg.into_rust(), + })), is_owned: true } +} +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_write(obj: *const ChannelPublicKeys) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelPublicKeys_read(ser: crate::c_types::u8slice) -> ChannelPublicKeys { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelPublicKeys { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelPublicKeys { inner: std::ptr::null_mut(), is_owned: true } + } +} +/// Create a new TxCreationKeys from channel base points and the per-commitment point +#[must_use] +#[no_mangle] +pub extern "C" fn TxCreationKeys_derive_new(per_commitment_point: crate::c_types::PublicKey, a_delayed_payment_base: crate::c_types::PublicKey, a_htlc_base: crate::c_types::PublicKey, b_revocation_base: crate::c_types::PublicKey, b_htlc_base: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_TxCreationKeysSecpErrorZ { + let mut ret = lightning::ln::chan_utils::TxCreationKeys::derive_new(&bitcoin::secp256k1::Secp256k1::new(), &per_commitment_point.into_rust(), &a_delayed_payment_base.into_rust(), &a_htlc_base.into_rust(), &b_revocation_base.into_rust(), &b_htlc_base.into_rust()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::chan_utils::TxCreationKeys { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::c_types::Secp256k1Error::from_rust(e) }) }; + local_ret +} + +/// A script either spendable by the revocation +/// key or the delayed_payment_key and satisfying the relative-locktime OP_CSV constrain. +/// Encumbering a `to_local` output on a commitment transaction or 2nd-stage HTLC transactions. +#[no_mangle] +pub extern "C" fn get_revokeable_redeemscript(revocation_key: crate::c_types::PublicKey, mut to_self_delay: u16, delayed_payment_key: crate::c_types::PublicKey) -> crate::c_types::derived::CVec_u8Z { + let mut ret = lightning::ln::chan_utils::get_revokeable_redeemscript(&revocation_key.into_rust(), to_self_delay, &delayed_payment_key.into_rust()); + ret.into_bytes().into() +} + + +use lightning::ln::chan_utils::HTLCOutputInCommitment as nativeHTLCOutputInCommitmentImport; +type nativeHTLCOutputInCommitment = nativeHTLCOutputInCommitmentImport; + +/// Information about an HTLC as it appears in a commitment transaction +#[must_use] +#[repr(C)] +pub struct HTLCOutputInCommitment { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeHTLCOutputInCommitment, + pub is_owned: bool, +} + +impl Drop for HTLCOutputInCommitment { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_free(this_ptr: HTLCOutputInCommitment) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn HTLCOutputInCommitment_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeHTLCOutputInCommitment); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl HTLCOutputInCommitment { + pub(crate) fn take_ptr(mut self) -> *mut nativeHTLCOutputInCommitment { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for HTLCOutputInCommitment { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn HTLCOutputInCommitment_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeHTLCOutputInCommitment)).clone() })) as *mut c_void +} +/// Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction). +/// Note that this is not the same as whether it is ountbound *from us*. To determine that you +/// need to compare this value to whether the commitment transaction in question is that of +/// the remote party or our own. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_get_offered(this_ptr: &HTLCOutputInCommitment) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.offered; + (*inner_val) +} +/// Whether the HTLC was \"offered\" (ie outbound in relation to this commitment transaction). +/// Note that this is not the same as whether it is ountbound *from us*. To determine that you +/// need to compare this value to whether the commitment transaction in question is that of +/// the remote party or our own. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_set_offered(this_ptr: &mut HTLCOutputInCommitment, mut val: bool) { + unsafe { &mut *this_ptr.inner }.offered = val; +} +/// The value, in msat, of the HTLC. The value as it appears in the commitment transaction is +/// this divided by 1000. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_get_amount_msat(this_ptr: &HTLCOutputInCommitment) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.amount_msat; + (*inner_val) +} +/// The value, in msat, of the HTLC. The value as it appears in the commitment transaction is +/// this divided by 1000. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_set_amount_msat(this_ptr: &mut HTLCOutputInCommitment, mut val: u64) { + unsafe { &mut *this_ptr.inner }.amount_msat = val; +} +/// The CLTV lock-time at which this HTLC expires. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_get_cltv_expiry(this_ptr: &HTLCOutputInCommitment) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry; + (*inner_val) +} +/// The CLTV lock-time at which this HTLC expires. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_set_cltv_expiry(this_ptr: &mut HTLCOutputInCommitment, mut val: u32) { + unsafe { &mut *this_ptr.inner }.cltv_expiry = val; +} +/// The hash of the preimage which unlocks this HTLC. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_get_payment_hash(this_ptr: &HTLCOutputInCommitment) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_hash; + &(*inner_val).0 +} +/// The hash of the preimage which unlocks this HTLC. +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_set_payment_hash(this_ptr: &mut HTLCOutputInCommitment, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.payment_hash = ::lightning::ln::channelmanager::PaymentHash(val.data); +} +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_write(obj: *const HTLCOutputInCommitment) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn HTLCOutputInCommitment_read(ser: crate::c_types::u8slice) -> HTLCOutputInCommitment { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + HTLCOutputInCommitment { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + HTLCOutputInCommitment { inner: std::ptr::null_mut(), is_owned: true } + } +} +/// note here that 'a_revocation_key' is generated using b_revocation_basepoint and a's +/// commitment secret. 'htlc' does *not* need to have its previous_output_index filled. +#[no_mangle] +pub extern "C" fn get_htlc_redeemscript(htlc: &crate::ln::chan_utils::HTLCOutputInCommitment, keys: &crate::ln::chan_utils::TxCreationKeys) -> crate::c_types::derived::CVec_u8Z { + let mut ret = lightning::ln::chan_utils::get_htlc_redeemscript(unsafe { &*htlc.inner }, unsafe { &*keys.inner }); + ret.into_bytes().into() +} + +/// Gets the redeemscript for a funding output from the two funding public keys. +/// Note that the order of funding public keys does not matter. +#[no_mangle] +pub extern "C" fn make_funding_redeemscript(a: crate::c_types::PublicKey, b: crate::c_types::PublicKey) -> crate::c_types::derived::CVec_u8Z { + let mut ret = lightning::ln::chan_utils::make_funding_redeemscript(&a.into_rust(), &b.into_rust()); + ret.into_bytes().into() +} + +/// panics if htlc.transaction_output_index.is_none()! +#[no_mangle] +pub extern "C" fn build_htlc_transaction(prev_hash: *const [u8; 32], mut feerate_per_kw: u32, mut to_self_delay: u16, htlc: &crate::ln::chan_utils::HTLCOutputInCommitment, a_delayed_payment_key: crate::c_types::PublicKey, revocation_key: crate::c_types::PublicKey) -> crate::c_types::derived::CVec_u8Z { + let mut ret = lightning::ln::chan_utils::build_htlc_transaction(&::bitcoin::hash_types::Txid::from_slice(&unsafe { &*prev_hash }[..]).unwrap(), feerate_per_kw, to_self_delay, unsafe { &*htlc.inner }, &a_delayed_payment_key.into_rust(), &revocation_key.into_rust()); + let mut local_ret = ::bitcoin::consensus::encode::serialize(&ret); + local_ret.into() +} + + +use lightning::ln::chan_utils::LocalCommitmentTransaction as nativeLocalCommitmentTransactionImport; +type nativeLocalCommitmentTransaction = nativeLocalCommitmentTransactionImport; + +/// We use this to track local commitment transactions and put off signing them until we are ready +/// to broadcast. This class can be used inside a signer implementation to generate a signature +/// given the relevant secret key. +#[must_use] +#[repr(C)] +pub struct LocalCommitmentTransaction { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeLocalCommitmentTransaction, + pub is_owned: bool, +} + +impl Drop for LocalCommitmentTransaction { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_free(this_ptr: LocalCommitmentTransaction) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn LocalCommitmentTransaction_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeLocalCommitmentTransaction); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl LocalCommitmentTransaction { + pub(crate) fn take_ptr(mut self) -> *mut nativeLocalCommitmentTransaction { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for LocalCommitmentTransaction { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn LocalCommitmentTransaction_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeLocalCommitmentTransaction)).clone() })) as *mut c_void +} +/// The commitment transaction itself, in unsigned form. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_get_unsigned_tx(this_ptr: &LocalCommitmentTransaction) -> crate::c_types::derived::CVec_u8Z { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.unsigned_tx; + let mut local_inner_val = ::bitcoin::consensus::encode::serialize(inner_val); + local_inner_val.into() +} +/// The commitment transaction itself, in unsigned form. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_set_unsigned_tx(this_ptr: &mut LocalCommitmentTransaction, mut val: crate::c_types::derived::CVec_u8Z) { + unsafe { &mut *this_ptr.inner }.unsigned_tx = ::bitcoin::consensus::encode::deserialize(&val.into_rust()[..]).unwrap(); +} +/// Our counterparty's signature for the transaction, above. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_get_their_sig(this_ptr: &LocalCommitmentTransaction) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.their_sig; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// Our counterparty's signature for the transaction, above. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_set_their_sig(this_ptr: &mut LocalCommitmentTransaction, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.their_sig = val.into_rust(); +} +/// The feerate paid per 1000-weight-unit in this commitment transaction. This value is +/// controlled by the channel initiator. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_get_feerate_per_kw(this_ptr: &LocalCommitmentTransaction) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.feerate_per_kw; + (*inner_val) +} +/// The feerate paid per 1000-weight-unit in this commitment transaction. This value is +/// controlled by the channel initiator. +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_set_feerate_per_kw(this_ptr: &mut LocalCommitmentTransaction, mut val: u32) { + unsafe { &mut *this_ptr.inner }.feerate_per_kw = val; +} +/// The HTLCs and remote htlc signatures which were included in this commitment transaction. +/// +/// Note that this includes all HTLCs, including ones which were considered dust and not +/// actually included in the transaction as it appears on-chain, but who's value is burned as +/// fees and not included in the to_local or to_remote outputs. +/// +/// The remote HTLC signatures in the second element will always be set for non-dust HTLCs, ie +/// those for which transaction_output_index.is_some(). +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_set_per_htlc(this_ptr: &mut LocalCommitmentTransaction, mut val: crate::c_types::derived::CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { let (mut orig_val_0_0, mut orig_val_0_1) = item.to_rust(); let mut local_orig_val_0_1 = if orig_val_0_1.is_null() { None } else { Some( { orig_val_0_1.into_rust() }) }; let mut local_val_0 = (*unsafe { Box::from_raw(orig_val_0_0.take_ptr()) }, local_orig_val_0_1); local_val_0 }); }; + unsafe { &mut *this_ptr.inner }.per_htlc = local_val; +} +/// Generate a new LocalCommitmentTransaction based on a raw commitment transaction, +/// remote signature and both parties keys. +/// +/// The unsigned transaction outputs must be consistent with htlc_data. This function +/// only checks that the shape and amounts are consistent, but does not check the scriptPubkey. +#[must_use] +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_new_missing_local_sig(mut unsigned_tx: crate::c_types::derived::CVec_u8Z, mut their_sig: crate::c_types::Signature, our_funding_key: crate::c_types::PublicKey, their_funding_key: crate::c_types::PublicKey, mut local_keys: crate::ln::chan_utils::TxCreationKeys, mut feerate_per_kw: u32, mut htlc_data: crate::c_types::derived::CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ) -> crate::ln::chan_utils::LocalCommitmentTransaction { + let mut local_htlc_data = Vec::new(); for mut item in htlc_data.into_rust().drain(..) { local_htlc_data.push( { let (mut orig_htlc_data_0_0, mut orig_htlc_data_0_1) = item.to_rust(); let mut local_orig_htlc_data_0_1 = if orig_htlc_data_0_1.is_null() { None } else { Some( { orig_htlc_data_0_1.into_rust() }) }; let mut local_htlc_data_0 = (*unsafe { Box::from_raw(orig_htlc_data_0_0.take_ptr()) }, local_orig_htlc_data_0_1); local_htlc_data_0 }); }; + let mut ret = lightning::ln::chan_utils::LocalCommitmentTransaction::new_missing_local_sig(::bitcoin::consensus::encode::deserialize(&unsigned_tx.into_rust()[..]).unwrap(), their_sig.into_rust(), &our_funding_key.into_rust(), &their_funding_key.into_rust(), *unsafe { Box::from_raw(local_keys.take_ptr()) }, feerate_per_kw, local_htlc_data); + crate::ln::chan_utils::LocalCommitmentTransaction { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// The pre-calculated transaction creation public keys. +/// An external validating signer should not trust these keys. +#[must_use] +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_trust_key_derivation(this_arg: &LocalCommitmentTransaction) -> crate::ln::chan_utils::TxCreationKeys { + let mut ret = unsafe { &*this_arg.inner }.trust_key_derivation(); + crate::ln::chan_utils::TxCreationKeys { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false } +} + +/// Get the txid of the local commitment transaction contained in this +/// LocalCommitmentTransaction +#[must_use] +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_txid(this_arg: &LocalCommitmentTransaction) -> crate::c_types::ThirtyTwoBytes { + let mut ret = unsafe { &*this_arg.inner }.txid(); + crate::c_types::ThirtyTwoBytes { data: ret.into_inner() } +} + +/// Gets our signature for the contained commitment transaction given our funding private key. +/// +/// Funding key is your key included in the 2-2 funding_outpoint lock. Should be provided +/// by your ChannelKeys. +/// Funding redeemscript is script locking funding_outpoint. This is the mutlsig script +/// between your own funding key and your counterparty's. Currently, this is provided in +/// ChannelKeys::sign_local_commitment() calls directly. +/// Channel value is amount locked in funding_outpoint. +#[must_use] +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_get_local_sig(this_arg: &LocalCommitmentTransaction, funding_key: *const [u8; 32], funding_redeemscript: crate::c_types::u8slice, mut channel_value_satoshis: u64) -> crate::c_types::Signature { + let mut ret = unsafe { &*this_arg.inner }.get_local_sig(&::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *funding_key}[..]).unwrap(), &::bitcoin::blockdata::script::Script::from(Vec::from(funding_redeemscript.to_slice())), channel_value_satoshis, &bitcoin::secp256k1::Secp256k1::new()); + crate::c_types::Signature::from_rust(&ret) +} + +/// Get a signature for each HTLC which was included in the commitment transaction (ie for +/// which HTLCOutputInCommitment::transaction_output_index.is_some()). +/// +/// The returned Vec has one entry for each HTLC, and in the same order. For HTLCs which were +/// considered dust and not included, a None entry exists, for all others a signature is +/// included. +#[must_use] +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_get_htlc_sigs(this_arg: &LocalCommitmentTransaction, htlc_base_key: *const [u8; 32], mut local_csv: u16) -> crate::c_types::derived::CResult_CVec_SignatureZNoneZ { + let mut ret = unsafe { &*this_arg.inner }.get_htlc_sigs(&::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *htlc_base_key}[..]).unwrap(), local_csv, &bitcoin::secp256k1::Secp256k1::new()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_ret_0 = Vec::new(); for item in o.drain(..) { local_ret_0.push( { let mut local_ret_0_0 = if item.is_none() { crate::c_types::Signature::null() } else { { crate::c_types::Signature::from_rust(&(item.unwrap())) } }; local_ret_0_0 }); }; local_ret_0.into() }), Err(mut e) => crate::c_types::CResultTempl::err( { 0u8 /*e*/ }) }; + local_ret +} + +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_write(obj: *const LocalCommitmentTransaction) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn LocalCommitmentTransaction_read(ser: crate::c_types::u8slice) -> LocalCommitmentTransaction { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + LocalCommitmentTransaction { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + LocalCommitmentTransaction { inner: std::ptr::null_mut(), is_owned: true } + } +} diff --git a/lightning-c-bindings/src/ln/channelmanager.rs b/lightning-c-bindings/src/ln/channelmanager.rs new file mode 100644 index 000000000..43e38b357 --- /dev/null +++ b/lightning-c-bindings/src/ln/channelmanager.rs @@ -0,0 +1,842 @@ +//! The top-level channel management and payment tracking stuff lives here. +//! +//! The ChannelManager is the main chunk of logic implementing the lightning protocol and is +//! responsible for tracking which channels are open, HTLCs are in flight and reestablishing those +//! upon reconnect to the relevant peer(s). +//! +//! It does not manage routing logic (see routing::router::get_route for that) nor does it manage constructing +//! on-chain transactions (it only monitors the chain to watch for any force-closes that might +//! imply it needs to fail HTLCs/payments/channels it manages). + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::ln::channelmanager::ChannelManager as nativeChannelManagerImport; +type nativeChannelManager = nativeChannelManagerImport; + +/// Manager which keeps track of a number of channels and sends messages to the appropriate +/// channel, also tracking HTLC preimages and forwarding onion packets appropriately. +/// +/// Implements ChannelMessageHandler, handling the multi-channel parts and passing things through +/// to individual Channels. +/// +/// Implements Writeable to write out all channel state to disk. Implies peer_disconnected() for +/// all peers during write/read (though does not modify this instance, only the instance being +/// serialized). This will result in any channels which have not yet exchanged funding_created (ie +/// called funding_transaction_generated for outbound channels). +/// +/// Note that you can be a bit lazier about writing out ChannelManager than you can be with +/// ChannelMonitors. With ChannelMonitors you MUST write each monitor update out to disk before +/// returning from ManyChannelMonitor::add_/update_monitor, with ChannelManagers, writing updates +/// happens out-of-band (and will prevent any other ChannelManager operations from occurring during +/// the serialization process). If the deserialized version is out-of-date compared to the +/// ChannelMonitors passed by reference to read(), those channels will be force-closed based on the +/// ChannelMonitor state and no funds will be lost (mod on-chain transaction fees). +/// +/// Note that the deserializer is only implemented for (Sha256dHash, ChannelManager), which +/// tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along +/// the \"reorg path\" (ie call block_disconnected() until you get to a common block and then call +/// block_connected() to step towards your best block) upon deserialization before using the +/// object! +/// +/// Note that ChannelManager is responsible for tracking liveness of its channels and generating +/// ChannelUpdate messages informing peers that the channel is temporarily disabled. To avoid +/// spam due to quick disconnection/reconnection, updates are not sent until the channel has been +/// offline for a full minute. In order to track this, you must call +/// timer_chan_freshness_every_min roughly once per minute, though it doesn't have to be perfect. +/// +/// Rather than using a plain ChannelManager, it is preferable to use either a SimpleArcChannelManager +/// a SimpleRefChannelManager, for conciseness. See their documentation for more details, but +/// essentially you should default to using a SimpleRefChannelManager, and use a +/// SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when +/// you're using lightning-net-tokio. +#[must_use] +#[repr(C)] +pub struct ChannelManager { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelManager, + pub is_owned: bool, +} + +impl Drop for ChannelManager { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelManager_free(this_ptr: ChannelManager) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelManager_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelManager); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelManager { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelManager { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::channelmanager::ChannelDetails as nativeChannelDetailsImport; +type nativeChannelDetails = nativeChannelDetailsImport; + +/// Details of a channel, as returned by ChannelManager::list_channels and ChannelManager::list_usable_channels +#[must_use] +#[repr(C)] +pub struct ChannelDetails { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelDetails, + pub is_owned: bool, +} + +impl Drop for ChannelDetails { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelDetails_free(this_ptr: ChannelDetails) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelDetails_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelDetails); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelDetails { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelDetails { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// The channel's ID (prior to funding transaction generation, this is a random 32 bytes, +/// thereafter this is the txid of the funding transaction xor the funding transaction output). +/// Note that this means this value is *not* persistent - it can change once during the +/// lifetime of the channel. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_channel_id(this_ptr: &ChannelDetails) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel's ID (prior to funding transaction generation, this is a random 32 bytes, +/// thereafter this is the txid of the funding transaction xor the funding transaction output). +/// Note that this means this value is *not* persistent - it can change once during the +/// lifetime of the channel. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_channel_id(this_ptr: &mut ChannelDetails, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The node_id of our counterparty +#[no_mangle] +pub extern "C" fn ChannelDetails_get_remote_network_id(this_ptr: &ChannelDetails) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.remote_network_id; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The node_id of our counterparty +#[no_mangle] +pub extern "C" fn ChannelDetails_set_remote_network_id(this_ptr: &mut ChannelDetails, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.remote_network_id = val.into_rust(); +} +/// The Features the channel counterparty provided upon last connection. +/// Useful for routing as it is the most up-to-date copy of the counterparty's features and +/// many routing-relevant features are present in the init context. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_counterparty_features(this_ptr: &ChannelDetails) -> crate::ln::features::InitFeatures { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.counterparty_features; + crate::ln::features::InitFeatures { inner: &mut (*inner_val), is_owned: false } +} +/// The Features the channel counterparty provided upon last connection. +/// Useful for routing as it is the most up-to-date copy of the counterparty's features and +/// many routing-relevant features are present in the init context. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_counterparty_features(this_ptr: &mut ChannelDetails, mut val: crate::ln::features::InitFeatures) { + unsafe { &mut *this_ptr.inner }.counterparty_features = *unsafe { Box::from_raw(val.take_ptr()) }; +} +/// The value, in satoshis, of this channel as appears in the funding output +#[no_mangle] +pub extern "C" fn ChannelDetails_get_channel_value_satoshis(this_ptr: &ChannelDetails) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_value_satoshis; + (*inner_val) +} +/// The value, in satoshis, of this channel as appears in the funding output +#[no_mangle] +pub extern "C" fn ChannelDetails_set_channel_value_satoshis(this_ptr: &mut ChannelDetails, mut val: u64) { + unsafe { &mut *this_ptr.inner }.channel_value_satoshis = val; +} +/// The user_id passed in to create_channel, or 0 if the channel was inbound. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_user_id(this_ptr: &ChannelDetails) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.user_id; + (*inner_val) +} +/// The user_id passed in to create_channel, or 0 if the channel was inbound. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_user_id(this_ptr: &mut ChannelDetails, mut val: u64) { + unsafe { &mut *this_ptr.inner }.user_id = val; +} +/// The available outbound capacity for sending HTLCs to the remote peer. This does not include +/// any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not +/// available for inclusion in new outbound HTLCs). This further does not include any pending +/// outgoing HTLCs which are awaiting some other resolution to be sent. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_outbound_capacity_msat(this_ptr: &ChannelDetails) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.outbound_capacity_msat; + (*inner_val) +} +/// The available outbound capacity for sending HTLCs to the remote peer. This does not include +/// any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not +/// available for inclusion in new outbound HTLCs). This further does not include any pending +/// outgoing HTLCs which are awaiting some other resolution to be sent. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_outbound_capacity_msat(this_ptr: &mut ChannelDetails, mut val: u64) { + unsafe { &mut *this_ptr.inner }.outbound_capacity_msat = val; +} +/// The available inbound capacity for the remote peer to send HTLCs to us. This does not +/// include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not +/// available for inclusion in new inbound HTLCs). +/// Note that there are some corner cases not fully handled here, so the actual available +/// inbound capacity may be slightly higher than this. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_inbound_capacity_msat(this_ptr: &ChannelDetails) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.inbound_capacity_msat; + (*inner_val) +} +/// The available inbound capacity for the remote peer to send HTLCs to us. This does not +/// include any pending HTLCs which are not yet fully resolved (and, thus, who's balance is not +/// available for inclusion in new inbound HTLCs). +/// Note that there are some corner cases not fully handled here, so the actual available +/// inbound capacity may be slightly higher than this. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_inbound_capacity_msat(this_ptr: &mut ChannelDetails, mut val: u64) { + unsafe { &mut *this_ptr.inner }.inbound_capacity_msat = val; +} +/// True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b) +/// the peer is connected, and (c) no monitor update failure is pending resolution. +#[no_mangle] +pub extern "C" fn ChannelDetails_get_is_live(this_ptr: &ChannelDetails) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.is_live; + (*inner_val) +} +/// True if the channel is (a) confirmed and funding_locked messages have been exchanged, (b) +/// the peer is connected, and (c) no monitor update failure is pending resolution. +#[no_mangle] +pub extern "C" fn ChannelDetails_set_is_live(this_ptr: &mut ChannelDetails, mut val: bool) { + unsafe { &mut *this_ptr.inner }.is_live = val; +} + +use lightning::ln::channelmanager::PaymentSendFailure as nativePaymentSendFailureImport; +type nativePaymentSendFailure = nativePaymentSendFailureImport; + +/// If a payment fails to send, it can be in one of several states. This enum is returned as the +/// Err() type describing which state the payment is in, see the description of individual enum +/// states for more. +#[must_use] +#[repr(C)] +pub struct PaymentSendFailure { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePaymentSendFailure, + pub is_owned: bool, +} + +impl Drop for PaymentSendFailure { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn PaymentSendFailure_free(this_ptr: PaymentSendFailure) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn PaymentSendFailure_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePaymentSendFailure); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl PaymentSendFailure { + pub(crate) fn take_ptr(mut self) -> *mut nativePaymentSendFailure { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Constructs a new ChannelManager to hold several channels and route between them. +/// +/// This is the main \"logic hub\" for all channel-related actions, and implements +/// ChannelMessageHandler. +/// +/// Non-proportional fees are fixed according to our risk using the provided fee estimator. +/// +/// panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`! +/// +/// Users must provide the current blockchain height from which to track onchain channel +/// funding outpoints and send payments with reliable timelocks. +/// +/// Users need to notify the new ChannelManager when a new block is connected or +/// disconnected using its `block_connected` and `block_disconnected` methods. +/// However, rather than calling these methods directly, the user should register +/// the ChannelManager as a listener to the BlockNotifier and call the BlockNotifier's +/// `block_(dis)connected` methods, which will notify all registered listeners in one +/// go. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_new(mut network: crate::bitcoin::network::Network, mut fee_est: crate::chain::chaininterface::FeeEstimator, mut monitor: crate::ln::channelmonitor::ManyChannelMonitor, mut tx_broadcaster: crate::chain::chaininterface::BroadcasterInterface, mut logger: crate::util::logger::Logger, mut keys_manager: crate::chain::keysinterface::KeysInterface, mut config: crate::util::config::UserConfig, mut current_blockchain_height: usize) -> ChannelManager { + let mut ret = lightning::ln::channelmanager::ChannelManager::new(network.into_bitcoin(), fee_est, monitor, tx_broadcaster, logger, keys_manager, *unsafe { Box::from_raw(config.take_ptr()) }, current_blockchain_height); + ChannelManager { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Creates a new outbound channel to the given remote node and with the given value. +/// +/// user_id will be provided back as user_channel_id in FundingGenerationReady and +/// FundingBroadcastSafe events to allow tracking of which events correspond with which +/// create_channel call. Note that user_channel_id defaults to 0 for inbound channels, so you +/// may wish to avoid using 0 for user_id here. +/// +/// If successful, will generate a SendOpenChannel message event, so you should probably poll +/// PeerManager::process_events afterwards. +/// +/// Raises APIError::APIMisuseError when channel_value_satoshis > 2**24 or push_msat is +/// greater than channel_value_satoshis * 1k or channel_value_satoshis is < 1000. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_create_channel(this_arg: &ChannelManager, mut their_network_key: crate::c_types::PublicKey, mut channel_value_satoshis: u64, mut push_msat: u64, mut user_id: u64, mut override_config: crate::util::config::UserConfig) -> crate::c_types::derived::CResult_NoneAPIErrorZ { + let mut local_override_config = if override_config.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(override_config.take_ptr()) } }) }; + let mut ret = unsafe { &*this_arg.inner }.create_channel(their_network_key.into_rust(), channel_value_satoshis, push_msat, user_id, local_override_config); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::util::errors::APIError::native_into(e) }) }; + local_ret +} + +/// Gets the list of open channels, in random order. See ChannelDetail field documentation for +/// more information. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_list_channels(this_arg: &ChannelManager) -> crate::c_types::derived::CVec_ChannelDetailsZ { + let mut ret = unsafe { &*this_arg.inner }.list_channels(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::ln::channelmanager::ChannelDetails { inner: Box::into_raw(Box::new(item)), is_owned: true } }); }; + local_ret.into() +} + +/// Gets the list of usable channels, in random order. Useful as an argument to +/// get_route to ensure non-announced channels are used. +/// +/// These are guaranteed to have their is_live value set to true, see the documentation for +/// ChannelDetails::is_live for more info on exactly what the criteria are. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_list_usable_channels(this_arg: &ChannelManager) -> crate::c_types::derived::CVec_ChannelDetailsZ { + let mut ret = unsafe { &*this_arg.inner }.list_usable_channels(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::ln::channelmanager::ChannelDetails { inner: Box::into_raw(Box::new(item)), is_owned: true } }); }; + local_ret.into() +} + +/// Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs +/// will be accepted on the given channel, and after additional timeout/the closing of all +/// pending HTLCs, the channel will be closed on chain. +/// +/// May generate a SendShutdown message event on success, which should be relayed. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_close_channel(this_arg: &ChannelManager, channel_id: *const [u8; 32]) -> crate::c_types::derived::CResult_NoneAPIErrorZ { + let mut ret = unsafe { &*this_arg.inner }.close_channel(unsafe { &*channel_id}); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::util::errors::APIError::native_into(e) }) }; + local_ret +} + +/// Force closes a channel, immediately broadcasting the latest local commitment transaction to +/// the chain and rejecting new HTLCs on the given channel. +#[no_mangle] +pub extern "C" fn ChannelManager_force_close_channel(this_arg: &ChannelManager, channel_id: *const [u8; 32]) { + unsafe { &*this_arg.inner }.force_close_channel(unsafe { &*channel_id}) +} + +/// Force close all channels, immediately broadcasting the latest local commitment transaction +/// for each to the chain and rejecting new HTLCs on each. +#[no_mangle] +pub extern "C" fn ChannelManager_force_close_all_channels(this_arg: &ChannelManager) { + unsafe { &*this_arg.inner }.force_close_all_channels() +} + +/// Sends a payment along a given route. +/// +/// Value parameters are provided via the last hop in route, see documentation for RouteHop +/// fields for more info. +/// +/// Note that if the payment_hash already exists elsewhere (eg you're sending a duplicative +/// payment), we don't do anything to stop you! We always try to ensure that if the provided +/// next hop knows the preimage to payment_hash they can claim an additional amount as +/// specified in the last hop in the route! Thus, you should probably do your own +/// payment_preimage tracking (which you should already be doing as they represent \"proof of +/// payment\") and prevent double-sends yourself. +/// +/// May generate SendHTLCs message(s) event on success, which should be relayed. +/// +/// Each path may have a different return value, and PaymentSendValue may return a Vec with +/// each entry matching the corresponding-index entry in the route paths, see +/// PaymentSendFailure for more info. +/// +/// In general, a path may raise: +/// * APIError::RouteError when an invalid route or forwarding parameter (cltv_delta, fee, +/// node public key) is specified. +/// * APIError::ChannelUnavailable if the next-hop channel is not available for updates +/// (including due to previous monitor update failure or new permanent monitor update +/// failure). +/// * APIError::MonitorUpdateFailed if a new monitor update failure prevented sending the +/// relevant updates. +/// +/// Note that depending on the type of the PaymentSendFailure the HTLC may have been +/// irrevocably committed to on our end. In such a case, do NOT retry the payment with a +/// different route unless you intend to pay twice! +/// +/// payment_secret is unrelated to payment_hash (or PaymentPreimage) and exists to authenticate +/// the sender to the recipient and prevent payment-probing (deanonymization) attacks. For +/// newer nodes, it will be provided to you in the invoice. If you do not have one, the Route +/// must not contain multiple paths as multi-path payments require a recipient-provided +/// payment_secret. +/// If a payment_secret *is* provided, we assume that the invoice had the payment_secret feature +/// bit set (either as required or as available). If multiple paths are present in the Route, +/// we assume the invoice had the basic_mpp feature set. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_send_payment(this_arg: &ChannelManager, route: &crate::routing::router::Route, mut payment_hash: crate::c_types::ThirtyTwoBytes, payment_secret: crate::c_types::ThirtyTwoBytes) -> crate::c_types::derived::CResult_NonePaymentSendFailureZ { + let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret.data) }) }; + let mut ret = unsafe { &*this_arg.inner }.send_payment(unsafe { &*route.inner }, ::lightning::ln::channelmanager::PaymentHash(payment_hash.data), &local_payment_secret); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::channelmanager::PaymentSendFailure { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Call this upon creation of a funding transaction for the given channel. +/// +/// Note that ALL inputs in the transaction pointed to by funding_txo MUST spend SegWit outputs +/// or your counterparty can steal your funds! +/// +/// Panics if a funding transaction has already been provided for this channel. +/// +/// May panic if the funding_txo is duplicative with some other channel (note that this should +/// be trivially prevented by using unique funding transaction keys per-channel). +#[no_mangle] +pub extern "C" fn ChannelManager_funding_transaction_generated(this_arg: &ChannelManager, temporary_channel_id: *const [u8; 32], mut funding_txo: crate::chain::transaction::OutPoint) { + unsafe { &*this_arg.inner }.funding_transaction_generated(unsafe { &*temporary_channel_id}, *unsafe { Box::from_raw(funding_txo.take_ptr()) }) +} + +/// Generates a signed node_announcement from the given arguments and creates a +/// BroadcastNodeAnnouncement event. Note that such messages will be ignored unless peers have +/// seen a channel_announcement from us (ie unless we have public channels open). +/// +/// RGB is a node \"color\" and alias is a printable human-readable string to describe this node +/// to humans. They carry no in-protocol meaning. +/// +/// addresses represent the set (possibly empty) of socket addresses on which this node accepts +/// incoming connections. These will be broadcast to the network, publicly tying these +/// addresses together. If you wish to preserve user privacy, addresses should likely contain +/// only Tor Onion addresses. +/// +/// Panics if addresses is absurdly large (more than 500). +#[no_mangle] +pub extern "C" fn ChannelManager_broadcast_node_announcement(this_arg: &ChannelManager, mut rgb: crate::c_types::ThreeBytes, mut alias: crate::c_types::ThirtyTwoBytes, mut addresses: crate::c_types::derived::CVec_NetAddressZ) { + let mut local_addresses = Vec::new(); for mut item in addresses.into_rust().drain(..) { local_addresses.push( { item.into_native() }); }; + unsafe { &*this_arg.inner }.broadcast_node_announcement(rgb.data, alias.data, local_addresses) +} + +/// Processes HTLCs which are pending waiting on random forward delay. +/// +/// Should only really ever be called in response to a PendingHTLCsForwardable event. +/// Will likely generate further events. +#[no_mangle] +pub extern "C" fn ChannelManager_process_pending_htlc_forwards(this_arg: &ChannelManager) { + unsafe { &*this_arg.inner }.process_pending_htlc_forwards() +} + +/// If a peer is disconnected we mark any channels with that peer as 'disabled'. +/// After some time, if channels are still disabled we need to broadcast a ChannelUpdate +/// to inform the network about the uselessness of these channels. +/// +/// This method handles all the details, and must be called roughly once per minute. +#[no_mangle] +pub extern "C" fn ChannelManager_timer_chan_freshness_every_min(this_arg: &ChannelManager) { + unsafe { &*this_arg.inner }.timer_chan_freshness_every_min() +} + +/// Indicates that the preimage for payment_hash is unknown or the received amount is incorrect +/// after a PaymentReceived event, failing the HTLC back to its origin and freeing resources +/// along the path (including in our own channel on which we received it). +/// Returns false if no payment was found to fail backwards, true if the process of failing the +/// HTLC backwards has been started. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_fail_htlc_backwards(this_arg: &ChannelManager, payment_hash: *const [u8; 32], payment_secret: crate::c_types::ThirtyTwoBytes) -> bool { + let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret.data) }) }; + let mut ret = unsafe { &*this_arg.inner }.fail_htlc_backwards(&::lightning::ln::channelmanager::PaymentHash(unsafe { *payment_hash }), &local_payment_secret); + ret +} + +/// Provides a payment preimage in response to a PaymentReceived event, returning true and +/// generating message events for the net layer to claim the payment, if possible. Thus, you +/// should probably kick the net layer to go send messages if this returns true! +/// +/// You must specify the expected amounts for this HTLC, and we will only claim HTLCs +/// available within a few percent of the expected amount. This is critical for several +/// reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the +/// payment_preimage without having provided the full value and b) it avoids certain +/// privacy-breaking recipient-probing attacks which may reveal payment activity to +/// motivated attackers. +/// +/// Note that the privacy concerns in (b) are not relevant in payments with a payment_secret +/// set. Thus, for such payments we will claim any payments which do not under-pay. +/// +/// May panic if called except in response to a PaymentReceived event. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_claim_funds(this_arg: &ChannelManager, mut payment_preimage: crate::c_types::ThirtyTwoBytes, payment_secret: crate::c_types::ThirtyTwoBytes, mut expected_amount: u64) -> bool { + let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret.data) }) }; + let mut ret = unsafe { &*this_arg.inner }.claim_funds(::lightning::ln::channelmanager::PaymentPreimage(payment_preimage.data), &local_payment_secret, expected_amount); + ret +} + +/// Gets the node_id held by this ChannelManager +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManager_get_our_node_id(this_arg: &ChannelManager) -> crate::c_types::PublicKey { + let mut ret = unsafe { &*this_arg.inner }.get_our_node_id(); + crate::c_types::PublicKey::from_rust(&ret) +} + +/// Restores a single, given channel to normal operation after a +/// ChannelMonitorUpdateErr::TemporaryFailure was returned from a channel monitor update +/// operation. +/// +/// All ChannelMonitor updates up to and including highest_applied_update_id must have been +/// fully committed in every copy of the given channels' ChannelMonitors. +/// +/// Note that there is no effect to calling with a highest_applied_update_id other than the +/// current latest ChannelMonitorUpdate and one call to this function after multiple +/// ChannelMonitorUpdateErr::TemporaryFailures is fine. The highest_applied_update_id field +/// exists largely only to prevent races between this and concurrent update_monitor calls. +/// +/// Thus, the anticipated use is, at a high level: +/// 1) You register a ManyChannelMonitor with this ChannelManager, +/// 2) it stores each update to disk, and begins updating any remote (eg watchtower) copies of +/// said ChannelMonitors as it can, returning ChannelMonitorUpdateErr::TemporaryFailures +/// any time it cannot do so instantly, +/// 3) update(s) are applied to each remote copy of a ChannelMonitor, +/// 4) once all remote copies are updated, you call this function with the update_id that +/// completed, and once it is the latest the Channel will be re-enabled. +#[no_mangle] +pub extern "C" fn ChannelManager_channel_monitor_updated(this_arg: &ChannelManager, funding_txo: &crate::chain::transaction::OutPoint, mut highest_applied_update_id: u64) { + unsafe { &*this_arg.inner }.channel_monitor_updated(unsafe { &*funding_txo.inner }, highest_applied_update_id) +} + +#[no_mangle] +pub extern "C" fn ChannelManager_as_MessageSendEventsProvider(this_arg: *const ChannelManager) -> crate::util::events::MessageSendEventsProvider { + crate::util::events::MessageSendEventsProvider { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + get_and_clear_pending_msg_events: ChannelManager_MessageSendEventsProvider_get_and_clear_pending_msg_events, + } +} +use lightning::util::events::MessageSendEventsProvider as MessageSendEventsProviderTraitImport; +#[must_use] +extern "C" fn ChannelManager_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChannelManager) }.get_and_clear_pending_msg_events(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::util::events::MessageSendEvent::native_into(item) }); }; + local_ret.into() +} + +#[no_mangle] +pub extern "C" fn ChannelManager_as_EventsProvider(this_arg: *const ChannelManager) -> crate::util::events::EventsProvider { + crate::util::events::EventsProvider { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + get_and_clear_pending_events: ChannelManager_EventsProvider_get_and_clear_pending_events, + } +} +use lightning::util::events::EventsProvider as EventsProviderTraitImport; +#[must_use] +extern "C" fn ChannelManager_EventsProvider_get_and_clear_pending_events(this_arg: *const c_void) -> crate::c_types::derived::CVec_EventZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChannelManager) }.get_and_clear_pending_events(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::util::events::Event::native_into(item) }); }; + local_ret.into() +} + +#[no_mangle] +pub extern "C" fn ChannelManager_as_ChainListener(this_arg: *const ChannelManager) -> crate::chain::chaininterface::ChainListener { + crate::chain::chaininterface::ChainListener { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + block_connected: ChannelManager_ChainListener_block_connected, + block_disconnected: ChannelManager_ChainListener_block_disconnected, + } +} +use lightning::chain::chaininterface::ChainListener as ChainListenerTraitImport; +extern "C" fn ChannelManager_ChainListener_block_connected(this_arg: *const c_void, header: *const [u8; 80], mut height: u32, mut txn_matched: crate::c_types::derived::CVec_TransactionZ, mut indexes_of_txn_matched: crate::c_types::usizeslice) { + let mut local_txn_matched = Vec::new(); for mut item in txn_matched.into_rust().drain(..) { local_txn_matched.push( { ::bitcoin::consensus::encode::deserialize(&item.into_rust()[..]).unwrap() }); }; + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.block_connected(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), height, &local_txn_matched.iter().collect::>()[..], indexes_of_txn_matched.to_slice()) +} +extern "C" fn ChannelManager_ChainListener_block_disconnected(this_arg: *const c_void, header: *const [u8; 80], unused_0: u32) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.block_disconnected(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), unused_0) +} + +#[no_mangle] +pub extern "C" fn ChannelManager_as_ChannelMessageHandler(this_arg: *const ChannelManager) -> crate::ln::msgs::ChannelMessageHandler { + crate::ln::msgs::ChannelMessageHandler { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + handle_open_channel: ChannelManager_ChannelMessageHandler_handle_open_channel, + handle_accept_channel: ChannelManager_ChannelMessageHandler_handle_accept_channel, + handle_funding_created: ChannelManager_ChannelMessageHandler_handle_funding_created, + handle_funding_signed: ChannelManager_ChannelMessageHandler_handle_funding_signed, + handle_funding_locked: ChannelManager_ChannelMessageHandler_handle_funding_locked, + handle_shutdown: ChannelManager_ChannelMessageHandler_handle_shutdown, + handle_closing_signed: ChannelManager_ChannelMessageHandler_handle_closing_signed, + handle_update_add_htlc: ChannelManager_ChannelMessageHandler_handle_update_add_htlc, + handle_update_fulfill_htlc: ChannelManager_ChannelMessageHandler_handle_update_fulfill_htlc, + handle_update_fail_htlc: ChannelManager_ChannelMessageHandler_handle_update_fail_htlc, + handle_update_fail_malformed_htlc: ChannelManager_ChannelMessageHandler_handle_update_fail_malformed_htlc, + handle_commitment_signed: ChannelManager_ChannelMessageHandler_handle_commitment_signed, + handle_revoke_and_ack: ChannelManager_ChannelMessageHandler_handle_revoke_and_ack, + handle_update_fee: ChannelManager_ChannelMessageHandler_handle_update_fee, + handle_announcement_signatures: ChannelManager_ChannelMessageHandler_handle_announcement_signatures, + peer_disconnected: ChannelManager_ChannelMessageHandler_peer_disconnected, + peer_connected: ChannelManager_ChannelMessageHandler_peer_connected, + handle_channel_reestablish: ChannelManager_ChannelMessageHandler_handle_channel_reestablish, + handle_error: ChannelManager_ChannelMessageHandler_handle_error, + MessageSendEventsProvider: crate::util::events::MessageSendEventsProvider { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + get_and_clear_pending_msg_events: ChannelManager_ChannelMessageHandler_get_and_clear_pending_msg_events, + }, + } +} +use lightning::ln::msgs::ChannelMessageHandler as ChannelMessageHandlerTraitImport; +extern "C" fn ChannelManager_ChannelMessageHandler_handle_open_channel(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, mut their_features: crate::ln::features::InitFeatures, msg: &crate::ln::msgs::OpenChannel) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_open_channel(&their_node_id.into_rust(), *unsafe { Box::from_raw(their_features.take_ptr()) }, unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_accept_channel(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, mut their_features: crate::ln::features::InitFeatures, msg: &crate::ln::msgs::AcceptChannel) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_accept_channel(&their_node_id.into_rust(), *unsafe { Box::from_raw(their_features.take_ptr()) }, unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_funding_created(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingCreated) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_funding_created(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_funding_signed(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingSigned) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_funding_signed(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_funding_locked(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingLocked) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_funding_locked(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_shutdown(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::Shutdown) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_shutdown(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_closing_signed(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ClosingSigned) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_closing_signed(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_update_add_htlc(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateAddHTLC) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_update_add_htlc(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFulfillHTLC) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_update_fulfill_htlc(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_update_fail_htlc(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFailHTLC) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_update_fail_htlc(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFailMalformedHTLC) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_update_fail_malformed_htlc(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_commitment_signed(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::CommitmentSigned) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_commitment_signed(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_revoke_and_ack(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::RevokeAndACK) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_revoke_and_ack(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_update_fee(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFee) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_update_fee(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_announcement_signatures(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::AnnouncementSignatures) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_announcement_signatures(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_channel_reestablish(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ChannelReestablish) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_channel_reestablish(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_peer_disconnected(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, mut no_connection_possible: bool) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.peer_disconnected(&their_node_id.into_rust(), no_connection_possible) +} +extern "C" fn ChannelManager_ChannelMessageHandler_peer_connected(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init_msg: &crate::ln::msgs::Init) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.peer_connected(&their_node_id.into_rust(), unsafe { &*init_msg.inner }) +} +extern "C" fn ChannelManager_ChannelMessageHandler_handle_error(this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ErrorMessage) { + unsafe { &mut *(this_arg as *mut nativeChannelManager) }.handle_error(&their_node_id.into_rust(), unsafe { &*msg.inner }) +} +use lightning::util::events::MessageSendEventsProvider as nativeMessageSendEventsProviderTrait; +#[must_use] +extern "C" fn ChannelManager_ChannelMessageHandler_get_and_clear_pending_msg_events(this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeChannelManager) }.get_and_clear_pending_msg_events(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::util::events::MessageSendEvent::native_into(item) }); }; + local_ret.into() +} + + +use lightning::ln::channelmanager::ChannelManagerReadArgs as nativeChannelManagerReadArgsImport; +type nativeChannelManagerReadArgs = nativeChannelManagerReadArgsImport<'static, crate::chain::keysinterface::ChannelKeys, crate::ln::channelmonitor::ManyChannelMonitor, crate::chain::chaininterface::BroadcasterInterface, crate::chain::keysinterface::KeysInterface, crate::chain::chaininterface::FeeEstimator, crate::util::logger::Logger>; + +/// Arguments for the creation of a ChannelManager that are not deserialized. +/// +/// At a high-level, the process for deserializing a ChannelManager and resuming normal operation +/// is: +/// 1) Deserialize all stored ChannelMonitors. +/// 2) Deserialize the ChannelManager by filling in this struct and calling <(Sha256dHash, +/// ChannelManager)>::read(reader, args). +/// This may result in closing some Channels if the ChannelMonitor is newer than the stored +/// ChannelManager state to ensure no loss of funds. Thus, transactions may be broadcasted. +/// 3) Register all relevant ChannelMonitor outpoints with your chain watch mechanism using +/// ChannelMonitor::get_monitored_outpoints and ChannelMonitor::get_funding_txo(). +/// 4) Reconnect blocks on your ChannelMonitors. +/// 5) Move the ChannelMonitors into your local ManyChannelMonitor. +/// 6) Disconnect/connect blocks on the ChannelManager. +/// 7) Register the new ChannelManager with your ChainWatchInterface. +#[must_use] +#[repr(C)] +pub struct ChannelManagerReadArgs { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelManagerReadArgs, + pub is_owned: bool, +} + +impl Drop for ChannelManagerReadArgs { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_free(this_ptr: ChannelManagerReadArgs) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelManagerReadArgs_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelManagerReadArgs); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelManagerReadArgs { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelManagerReadArgs { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// The keys provider which will give us relevant keys. Some keys will be loaded during +/// deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_keys_manager(this_ptr: &ChannelManagerReadArgs) -> *const crate::chain::keysinterface::KeysInterface { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.keys_manager; + &(*inner_val) +} +/// The keys provider which will give us relevant keys. Some keys will be loaded during +/// deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_keys_manager(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::chain::keysinterface::KeysInterface) { + unsafe { &mut *this_ptr.inner }.keys_manager = val; +} +/// The fee_estimator for use in the ChannelManager in the future. +/// +/// No calls to the FeeEstimator will be made during deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_fee_estimator(this_ptr: &ChannelManagerReadArgs) -> *const crate::chain::chaininterface::FeeEstimator { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_estimator; + &(*inner_val) +} +/// The fee_estimator for use in the ChannelManager in the future. +/// +/// No calls to the FeeEstimator will be made during deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_fee_estimator(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::chain::chaininterface::FeeEstimator) { + unsafe { &mut *this_ptr.inner }.fee_estimator = val; +} +/// The ManyChannelMonitor for use in the ChannelManager in the future. +/// +/// No calls to the ManyChannelMonitor will be made during deserialization. It is assumed that +/// you have deserialized ChannelMonitors separately and will add them to your +/// ManyChannelMonitor after deserializing this ChannelManager. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_monitor(this_ptr: &ChannelManagerReadArgs) -> *const crate::ln::channelmonitor::ManyChannelMonitor { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.monitor; + &(*inner_val) +} +/// The ManyChannelMonitor for use in the ChannelManager in the future. +/// +/// No calls to the ManyChannelMonitor will be made during deserialization. It is assumed that +/// you have deserialized ChannelMonitors separately and will add them to your +/// ManyChannelMonitor after deserializing this ChannelManager. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_monitor(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::ln::channelmonitor::ManyChannelMonitor) { + unsafe { &mut *this_ptr.inner }.monitor = val; +} +/// The BroadcasterInterface which will be used in the ChannelManager in the future and may be +/// used to broadcast the latest local commitment transactions of channels which must be +/// force-closed during deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: &ChannelManagerReadArgs) -> *const crate::chain::chaininterface::BroadcasterInterface { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.tx_broadcaster; + &(*inner_val) +} +/// The BroadcasterInterface which will be used in the ChannelManager in the future and may be +/// used to broadcast the latest local commitment transactions of channels which must be +/// force-closed during deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::chain::chaininterface::BroadcasterInterface) { + unsafe { &mut *this_ptr.inner }.tx_broadcaster = val; +} +/// The Logger for use in the ChannelManager and which may be used to log information during +/// deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_logger(this_ptr: &ChannelManagerReadArgs) -> *const crate::util::logger::Logger { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.logger; + &(*inner_val) +} +/// The Logger for use in the ChannelManager and which may be used to log information during +/// deserialization. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_logger(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::util::logger::Logger) { + unsafe { &mut *this_ptr.inner }.logger = val; +} +/// Default settings used for new channels. Any existing channels will continue to use the +/// runtime settings which were stored when the ChannelManager was serialized. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_get_default_config(this_ptr: &ChannelManagerReadArgs) -> crate::util::config::UserConfig { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.default_config; + crate::util::config::UserConfig { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// Default settings used for new channels. Any existing channels will continue to use the +/// runtime settings which were stored when the ChannelManager was serialized. +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_set_default_config(this_ptr: &mut ChannelManagerReadArgs, mut val: crate::util::config::UserConfig) { + unsafe { &mut *this_ptr.inner }.default_config = *unsafe { Box::from_raw(val.take_ptr()) }; +} +/// Simple utility function to create a ChannelManagerReadArgs which creates the monitor +/// HashMap for you. This is primarily useful for C bindings where it is not practical to +/// populate a HashMap directly from C. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelManagerReadArgs_new(mut keys_manager: crate::chain::keysinterface::KeysInterface, mut fee_estimator: crate::chain::chaininterface::FeeEstimator, mut monitor: crate::ln::channelmonitor::ManyChannelMonitor, mut tx_broadcaster: crate::chain::chaininterface::BroadcasterInterface, mut logger: crate::util::logger::Logger, mut default_config: crate::util::config::UserConfig, mut channel_monitors: crate::c_types::derived::CVec_ChannelMonitorZ) -> ChannelManagerReadArgs { + let mut local_channel_monitors = Vec::new(); for mut item in channel_monitors.into_rust().drain(..) { local_channel_monitors.push( { unsafe { &mut *item.inner } }); }; + let mut ret = lightning::ln::channelmanager::ChannelManagerReadArgs::new(keys_manager, fee_estimator, monitor, tx_broadcaster, logger, *unsafe { Box::from_raw(default_config.take_ptr()) }, local_channel_monitors); + ChannelManagerReadArgs { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + diff --git a/lightning-c-bindings/src/ln/channelmonitor.rs b/lightning-c-bindings/src/ln/channelmonitor.rs new file mode 100644 index 000000000..cd6507acf --- /dev/null +++ b/lightning-c-bindings/src/ln/channelmonitor.rs @@ -0,0 +1,550 @@ +//! The logic to monitor for on-chain transactions and create the relevant claim responses lives +//! here. +//! +//! ChannelMonitor objects are generated by ChannelManager in response to relevant +//! messages/actions, and MUST be persisted to disk (and, preferably, remotely) before progress can +//! be made in responding to certain messages, see ManyChannelMonitor for more. +//! +//! Note that ChannelMonitors are an important part of the lightning trust model and a copy of the +//! latest ChannelMonitor must always be actively monitoring for chain updates (and no out-of-date +//! ChannelMonitors should do so). Thus, if you're building rust-lightning into an HSM or other +//! security-domain-separated system design, you should consider having multiple paths for +//! ChannelMonitors to get out of the HSM and onto monitoring devices. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::ln::channelmonitor::ChannelMonitorUpdate as nativeChannelMonitorUpdateImport; +type nativeChannelMonitorUpdate = nativeChannelMonitorUpdateImport; + +/// An update generated by the underlying Channel itself which contains some new information the +/// ChannelMonitor should be made aware of. +#[must_use] +#[repr(C)] +pub struct ChannelMonitorUpdate { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelMonitorUpdate, + pub is_owned: bool, +} + +impl Drop for ChannelMonitorUpdate { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelMonitorUpdate_free(this_ptr: ChannelMonitorUpdate) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelMonitorUpdate_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelMonitorUpdate); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelMonitorUpdate { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelMonitorUpdate { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelMonitorUpdate { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelMonitorUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelMonitorUpdate)).clone() })) as *mut c_void +} +/// The sequence number of this update. Updates *must* be replayed in-order according to this +/// sequence number (and updates may panic if they are not). The update_id values are strictly +/// increasing and increase by one for each new update. +/// +/// This sequence number is also used to track up to which points updates which returned +/// ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given +/// ChannelMonitor when ChannelManager::channel_monitor_updated is called. +#[no_mangle] +pub extern "C" fn ChannelMonitorUpdate_get_update_id(this_ptr: &ChannelMonitorUpdate) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.update_id; + (*inner_val) +} +/// The sequence number of this update. Updates *must* be replayed in-order according to this +/// sequence number (and updates may panic if they are not). The update_id values are strictly +/// increasing and increase by one for each new update. +/// +/// This sequence number is also used to track up to which points updates which returned +/// ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given +/// ChannelMonitor when ChannelManager::channel_monitor_updated is called. +#[no_mangle] +pub extern "C" fn ChannelMonitorUpdate_set_update_id(this_ptr: &mut ChannelMonitorUpdate, mut val: u64) { + unsafe { &mut *this_ptr.inner }.update_id = val; +} +#[no_mangle] +pub extern "C" fn ChannelMonitorUpdate_write(obj: *const ChannelMonitorUpdate) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelMonitorUpdate_read(ser: crate::c_types::u8slice) -> ChannelMonitorUpdate { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelMonitorUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelMonitorUpdate { inner: std::ptr::null_mut(), is_owned: true } + } +} +/// An error enum representing a failure to persist a channel monitor update. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum ChannelMonitorUpdateErr { + /// Used to indicate a temporary failure (eg connection to a watchtower or remote backup of + /// our state failed, but is expected to succeed at some point in the future). + /// + /// Such a failure will \"freeze\" a channel, preventing us from revoking old states or + /// submitting new commitment transactions to the remote party. Once the update(s) which failed + /// have been successfully applied, ChannelManager::channel_monitor_updated can be used to + /// restore the channel to an operational state. + /// + /// Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If + /// you return a TemporaryFailure you must ensure that it is written to disk safely before + /// writing out the latest ChannelManager state. + /// + /// Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur + /// (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting + /// to claim it on this channel) and those updates must be applied wherever they can be. At + /// least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should + /// be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to + /// the channel which would invalidate previous ChannelMonitors are not made when a channel has + /// been \"frozen\". + /// + /// Note that even if updates made after TemporaryFailure succeed you must still call + /// channel_monitor_updated to ensure you have the latest monitor and re-enable normal channel + /// operation. + /// + /// Note that the update being processed here will not be replayed for you when you call + /// ChannelManager::channel_monitor_updated, so you must store the update itself along + /// with the persisted ChannelMonitor on your own local disk prior to returning a + /// TemporaryFailure. You may, of course, employ a journaling approach, storing only the + /// ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at + /// reload-time. + /// + /// For deployments where a copy of ChannelMonitors and other local state are backed up in a + /// remote location (with local copies persisted immediately), it is anticipated that all + /// updates will return TemporaryFailure until the remote copies could be updated. + TemporaryFailure, + /// Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a + /// different watchtower and cannot update with all watchtowers that were previously informed + /// of this channel). This will force-close the channel in question (which will generate one + /// final ChannelMonitorUpdate which must be delivered to at least one ChannelMonitor copy). + /// + /// Should also be used to indicate a failure to update the local persisted copy of the channel + /// monitor. + PermanentFailure, +} +use lightning::ln::channelmonitor::ChannelMonitorUpdateErr as nativeChannelMonitorUpdateErr; +impl ChannelMonitorUpdateErr { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeChannelMonitorUpdateErr { + match self { + ChannelMonitorUpdateErr::TemporaryFailure => nativeChannelMonitorUpdateErr::TemporaryFailure, + ChannelMonitorUpdateErr::PermanentFailure => nativeChannelMonitorUpdateErr::PermanentFailure, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeChannelMonitorUpdateErr { + match self { + ChannelMonitorUpdateErr::TemporaryFailure => nativeChannelMonitorUpdateErr::TemporaryFailure, + ChannelMonitorUpdateErr::PermanentFailure => nativeChannelMonitorUpdateErr::PermanentFailure, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeChannelMonitorUpdateErr) -> Self { + match native { + nativeChannelMonitorUpdateErr::TemporaryFailure => ChannelMonitorUpdateErr::TemporaryFailure, + nativeChannelMonitorUpdateErr::PermanentFailure => ChannelMonitorUpdateErr::PermanentFailure, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeChannelMonitorUpdateErr) -> Self { + match native { + nativeChannelMonitorUpdateErr::TemporaryFailure => ChannelMonitorUpdateErr::TemporaryFailure, + nativeChannelMonitorUpdateErr::PermanentFailure => ChannelMonitorUpdateErr::PermanentFailure, + } + } +} + +use lightning::ln::channelmonitor::MonitorUpdateError as nativeMonitorUpdateErrorImport; +type nativeMonitorUpdateError = nativeMonitorUpdateErrorImport; + +/// General Err type for ChannelMonitor actions. Generally, this implies that the data provided is +/// inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this +/// means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was +/// corrupted. +/// Contains a human-readable error message. +#[must_use] +#[repr(C)] +pub struct MonitorUpdateError { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeMonitorUpdateError, + pub is_owned: bool, +} + +impl Drop for MonitorUpdateError { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn MonitorUpdateError_free(this_ptr: MonitorUpdateError) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn MonitorUpdateError_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMonitorUpdateError); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl MonitorUpdateError { + pub(crate) fn take_ptr(mut self) -> *mut nativeMonitorUpdateError { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::channelmonitor::MonitorEvent as nativeMonitorEventImport; +type nativeMonitorEvent = nativeMonitorEventImport; + +/// An event to be processed by the ChannelManager. +#[must_use] +#[repr(C)] +pub struct MonitorEvent { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeMonitorEvent, + pub is_owned: bool, +} + +impl Drop for MonitorEvent { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn MonitorEvent_free(this_ptr: MonitorEvent) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn MonitorEvent_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMonitorEvent); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl MonitorEvent { + pub(crate) fn take_ptr(mut self) -> *mut nativeMonitorEvent { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::channelmonitor::HTLCUpdate as nativeHTLCUpdateImport; +type nativeHTLCUpdate = nativeHTLCUpdateImport; + +/// Simple structure send back by ManyChannelMonitor in case of HTLC detected onchain from a +/// forward channel and from which info are needed to update HTLC in a backward channel. +#[must_use] +#[repr(C)] +pub struct HTLCUpdate { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeHTLCUpdate, + pub is_owned: bool, +} + +impl Drop for HTLCUpdate { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn HTLCUpdate_free(this_ptr: HTLCUpdate) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn HTLCUpdate_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeHTLCUpdate); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl HTLCUpdate { + pub(crate) fn take_ptr(mut self) -> *mut nativeHTLCUpdate { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for HTLCUpdate { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn HTLCUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeHTLCUpdate)).clone() })) as *mut c_void +} +#[no_mangle] +pub extern "C" fn HTLCUpdate_write(obj: *const HTLCUpdate) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn HTLCUpdate_read(ser: crate::c_types::u8slice) -> HTLCUpdate { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + HTLCUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + HTLCUpdate { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::ln::channelmonitor::ChannelMonitor as nativeChannelMonitorImport; +type nativeChannelMonitor = nativeChannelMonitorImport; + +/// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates +/// on-chain transactions to ensure no loss of funds occurs. +/// +/// You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date +/// information and are actively monitoring the chain. +/// +/// Pending Events or updated HTLCs which have not yet been read out by +/// get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and +/// reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events +/// gotten are fully handled before re-serializing the new state. +#[must_use] +#[repr(C)] +pub struct ChannelMonitor { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelMonitor, + pub is_owned: bool, +} + +impl Drop for ChannelMonitor { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelMonitor_free(this_ptr: ChannelMonitor) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelMonitor_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelMonitor); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelMonitor { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelMonitor { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Simple trait indicating ability to track a set of ChannelMonitors and multiplex events between +/// them. Generally should be implemented by keeping a local SimpleManyChannelMonitor and passing +/// events to it, while also taking any add/update_monitor events and passing them to some remote +/// server(s). +/// +/// In general, you must always have at least one local copy in memory, which must never fail to +/// update (as it is responsible for broadcasting the latest state in case the channel is closed), +/// and then persist it to various on-disk locations. If, for some reason, the in-memory copy fails +/// to update (eg out-of-memory or some other condition), you must immediately shut down without +/// taking any further action such as writing the current state to disk. This should likely be +/// accomplished via panic!() or abort(). +/// +/// Note that any updates to a channel's monitor *must* be applied to each instance of the +/// channel's monitor everywhere (including remote watchtowers) *before* this function returns. If +/// an update occurs and a remote watchtower is left with old state, it may broadcast transactions +/// which we have revoked, allowing our counterparty to claim all funds in the channel! +/// +/// User needs to notify implementors of ManyChannelMonitor when a new block is connected or +/// disconnected using their `block_connected` and `block_disconnected` methods. However, rather +/// than calling these methods directly, the user should register implementors as listeners to the +/// BlockNotifier and call the BlockNotifier's `block_(dis)connected` methods, which will notify +/// all registered listeners in one go. +#[repr(C)] +pub struct ManyChannelMonitor { + pub this_arg: *mut c_void, + /// Adds a monitor for the given `funding_txo`. + /// + /// Implementer must also ensure that the funding_txo txid *and* outpoint are registered with + /// any relevant ChainWatchInterfaces such that the provided monitor receives block_connected + /// callbacks with the funding transaction, or any spends of it. + /// + /// Further, the implementer must also ensure that each output returned in + /// monitor.get_outputs_to_watch() is registered to ensure that the provided monitor learns about + /// any spends of any of the outputs. + /// + /// Any spends of outputs which should have been registered which aren't passed to + /// ChannelMonitors via block_connected may result in FUNDS LOSS. + #[must_use] + pub add_monitor: extern "C" fn (this_arg: *const c_void, funding_txo: crate::chain::transaction::OutPoint, monitor: crate::ln::channelmonitor::ChannelMonitor) -> crate::c_types::derived::CResult_NoneChannelMonitorUpdateErrZ, + /// Updates a monitor for the given `funding_txo`. + /// + /// Implementer must also ensure that the funding_txo txid *and* outpoint are registered with + /// any relevant ChainWatchInterfaces such that the provided monitor receives block_connected + /// callbacks with the funding transaction, or any spends of it. + /// + /// Further, the implementer must also ensure that each output returned in + /// monitor.get_watch_outputs() is registered to ensure that the provided monitor learns about + /// any spends of any of the outputs. + /// + /// Any spends of outputs which should have been registered which aren't passed to + /// ChannelMonitors via block_connected may result in FUNDS LOSS. + #[must_use] + pub update_monitor: extern "C" fn (this_arg: *const c_void, funding_txo: crate::chain::transaction::OutPoint, monitor: crate::ln::channelmonitor::ChannelMonitorUpdate) -> crate::c_types::derived::CResult_NoneChannelMonitorUpdateErrZ, + /// Used by ChannelManager to get list of HTLC resolved onchain and which needed to be updated + /// with success or failure. + /// + /// You should probably just call through to + /// ChannelMonitor::get_and_clear_pending_monitor_events() for each ChannelMonitor and return + /// the full list. + #[must_use] + pub get_and_clear_pending_monitor_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_MonitorEventZ, + pub free: Option, +} +unsafe impl Send for ManyChannelMonitor {} +unsafe impl Sync for ManyChannelMonitor {} + +use lightning::ln::channelmonitor::ManyChannelMonitor as rustManyChannelMonitor; +impl rustManyChannelMonitor for ManyChannelMonitor { + type Keys = crate::chain::keysinterface::ChannelKeys; + fn add_monitor(&self, funding_txo: lightning::chain::transaction::OutPoint, monitor: lightning::ln::channelmonitor::ChannelMonitor) -> Result<(), lightning::ln::channelmonitor::ChannelMonitorUpdateErr> { + let mut ret = (self.add_monitor)(self.this_arg, crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo)), is_owned: true }, crate::ln::channelmonitor::ChannelMonitor { inner: Box::into_raw(Box::new(monitor)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(ret.contents.result.take_ptr()) })*/ }), false => Err( { (*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).into_native() })}; + local_ret + } + fn update_monitor(&self, funding_txo: lightning::chain::transaction::OutPoint, monitor: lightning::ln::channelmonitor::ChannelMonitorUpdate) -> Result<(), lightning::ln::channelmonitor::ChannelMonitorUpdateErr> { + let mut ret = (self.update_monitor)(self.this_arg, crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo)), is_owned: true }, crate::ln::channelmonitor::ChannelMonitorUpdate { inner: Box::into_raw(Box::new(monitor)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(ret.contents.result.take_ptr()) })*/ }), false => Err( { (*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).into_native() })}; + local_ret + } + fn get_and_clear_pending_monitor_events(&self) -> Vec { + let mut ret = (self.get_and_clear_pending_monitor_events)(self.this_arg); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + local_ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for ManyChannelMonitor { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn ManyChannelMonitor_free(this_ptr: ManyChannelMonitor) { } +impl Drop for ManyChannelMonitor { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// Updates a ChannelMonitor on the basis of some new information provided by the Channel +/// itself. +/// +/// panics if the given update is not the next update by update_id. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_update_monitor(this_arg: &mut ChannelMonitor, mut updates: crate::ln::channelmonitor::ChannelMonitorUpdate, broadcaster: &crate::chain::chaininterface::BroadcasterInterface, logger: &crate::util::logger::Logger) -> crate::c_types::derived::CResult_NoneMonitorUpdateErrorZ { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.update_monitor(*unsafe { Box::from_raw(updates.take_ptr()) }, broadcaster, logger); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::channelmonitor::MonitorUpdateError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this +/// ChannelMonitor. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_get_latest_update_id(this_arg: &ChannelMonitor) -> u64 { + let mut ret = unsafe { &*this_arg.inner }.get_latest_update_id(); + ret +} + +/// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_get_funding_txo(this_arg: &ChannelMonitor) -> crate::c_types::derived::C2Tuple_OutPointScriptZ { + let mut ret = unsafe { &*this_arg.inner }.get_funding_txo(); + let (ref orig_ret_0, ref orig_ret_1) = ret; let mut local_ret = (crate::chain::transaction::OutPoint { inner: unsafe { ( (&(*orig_ret_0) as *const _) as *mut _) }, is_owned: false }, orig_ret_1.clone().into_bytes().into()).into(); + local_ret +} + +/// Get the list of HTLCs who's status has been updated on chain. This should be called by +/// ChannelManager via ManyChannelMonitor::get_and_clear_pending_monitor_events(). +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: &mut ChannelMonitor) -> crate::c_types::derived::CVec_MonitorEventZ { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_and_clear_pending_monitor_events(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::ln::channelmonitor::MonitorEvent { inner: Box::into_raw(Box::new(item)), is_owned: true } }); }; + local_ret.into() +} + +/// Gets the list of pending events which were generated by previous actions, clearing the list +/// in the process. +/// +/// This is called by ManyChannelMonitor::get_and_clear_pending_events() and is equivalent to +/// EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do +/// no internal locking in ChannelMonitors. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_get_and_clear_pending_events(this_arg: &mut ChannelMonitor) -> crate::c_types::derived::CVec_EventZ { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_and_clear_pending_events(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::util::events::Event::native_into(item) }); }; + local_ret.into() +} + +/// Used by ChannelManager deserialization to broadcast the latest local state if its copy of +/// the Channel was out-of-date. You may use it to get a broadcastable local toxic tx in case of +/// fallen-behind, i.e when receiving a channel_reestablish with a proof that our remote side knows +/// a higher revocation secret than the local commitment number we are aware of. Broadcasting these +/// transactions are UNSAFE, as they allow remote side to punish you. Nevertheless you may want to +/// broadcast them if remote don't close channel with his higher commitment transaction after a +/// substantial amount of time (a month or even a year) to get back funds. Best may be to contact +/// out-of-band the other node operator to coordinate with him if option is available to you. +/// In any-case, choice is up to the user. +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelMonitor_get_latest_local_commitment_txn(this_arg: &mut ChannelMonitor, logger: &crate::util::logger::Logger) -> crate::c_types::derived::CVec_TransactionZ { + let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_latest_local_commitment_txn(logger); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { let mut local_ret_0 = ::bitcoin::consensus::encode::serialize(&item); local_ret_0.into() }); }; + local_ret.into() +} + diff --git a/lightning-c-bindings/src/ln/features.rs b/lightning-c-bindings/src/ln/features.rs new file mode 100644 index 000000000..44d2d68df --- /dev/null +++ b/lightning-c-bindings/src/ln/features.rs @@ -0,0 +1,136 @@ +//! Feature flag definitions for the Lightning protocol according to [BOLT #9]. +//! +//! Lightning nodes advertise a supported set of operation through feature flags. Features are +//! applicable for a specific context as indicated in some [messages]. [`Features`] encapsulates +//! behavior for specifying and checking feature flags for a particular context. Each feature is +//! defined internally by a trait specifying the corresponding flags (i.e., even and odd bits). A +//! [`Context`] is used to parameterize [`Features`] and defines which features it can support. +//! +//! Whether a feature is considered \"known\" or \"unknown\" is relative to the implementation, whereas +//! the term \"supports\" is used in reference to a particular set of [`Features`]. That is, a node +//! supports a feature if it advertises the feature (as either required or optional) to its peers. +//! And the implementation can interpret a feature if the feature is known to it. +//! +//! [BOLT #9]: https://github.com/lightningnetwork/lightning-rfc/blob/master/09-features.md +//! [messages]: ../msgs/index.html +//! [`Features`]: struct.Features.html +//! [`Context`]: sealed/trait.Context.html + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::ln::features::InitFeatures as nativeInitFeaturesImport; +type nativeInitFeatures = nativeInitFeaturesImport; + +/// Features used within an `init` message. +#[must_use] +#[repr(C)] +pub struct InitFeatures { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeInitFeatures, + pub is_owned: bool, +} + +impl Drop for InitFeatures { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn InitFeatures_free(this_ptr: InitFeatures) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn InitFeatures_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInitFeatures); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl InitFeatures { + pub(crate) fn take_ptr(mut self) -> *mut nativeInitFeatures { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::features::NodeFeatures as nativeNodeFeaturesImport; +type nativeNodeFeatures = nativeNodeFeaturesImport; + +/// Features used within a `node_announcement` message. +#[must_use] +#[repr(C)] +pub struct NodeFeatures { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNodeFeatures, + pub is_owned: bool, +} + +impl Drop for NodeFeatures { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NodeFeatures_free(this_ptr: NodeFeatures) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NodeFeatures_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeFeatures); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NodeFeatures { + pub(crate) fn take_ptr(mut self) -> *mut nativeNodeFeatures { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::features::ChannelFeatures as nativeChannelFeaturesImport; +type nativeChannelFeatures = nativeChannelFeaturesImport; + +/// Features used within a `channel_announcement` message. +#[must_use] +#[repr(C)] +pub struct ChannelFeatures { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelFeatures, + pub is_owned: bool, +} + +impl Drop for ChannelFeatures { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelFeatures_free(this_ptr: ChannelFeatures) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelFeatures_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelFeatures); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelFeatures { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelFeatures { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} diff --git a/lightning-c-bindings/src/ln/mod.rs b/lightning-c-bindings/src/ln/mod.rs new file mode 100644 index 000000000..69f17a0b5 --- /dev/null +++ b/lightning-c-bindings/src/ln/mod.rs @@ -0,0 +1,21 @@ +//! High level lightning structs and impls live here. +//! +//! You probably want to create a channelmanager::ChannelManager, and a routing::NetGraphMsgHandler first. +//! Then, you probably want to pass them both on to a peer_handler::PeerManager and use that to +//! create/manage connections and call get_and_clear_pending_events after each action, handling +//! them appropriately. +//! +//! When you want to open/close a channel or send a payment, call into your ChannelManager and when +//! you want to learn things about the network topology (eg get a route for sending a payment), +//! call into your NetGraphMsgHandler. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +pub mod channelmanager; +pub mod channelmonitor; +pub mod msgs; +pub mod peer_handler; +pub mod chan_utils; +pub mod features; diff --git a/lightning-c-bindings/src/ln/msgs.rs b/lightning-c-bindings/src/ln/msgs.rs new file mode 100644 index 000000000..6726b9521 --- /dev/null +++ b/lightning-c-bindings/src/ln/msgs.rs @@ -0,0 +1,3867 @@ +//! Wire messages, traits representing wire message handlers, and a few error types live here. +//! +//! For a normal node you probably don't need to use anything here, however, if you wish to split a +//! node into an internet-facing route/message socket handling daemon and a separate daemon (or +//! server entirely) which handles only channel-related messages you may wish to implement +//! ChannelMessageHandler yourself and use it to re-serialize messages and pass them across +//! daemons/servers. +//! +//! Note that if you go with such an architecture (instead of passing raw socket events to a +//! non-internet-facing system) you trust the frontend internet-facing system to not lie about the +//! source node_id of the message, however this does allow you to significantly reduce bandwidth +//! between the systems as routing messages can represent a significant chunk of bandwidth usage +//! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids +//! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send +//! raw socket events into your non-internet-facing system and then send routing events back to +//! track the network on the less-secure system. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::ln::msgs::DecodeError as nativeDecodeErrorImport; +type nativeDecodeError = nativeDecodeErrorImport; + +/// An error in decoding a message or struct. +#[must_use] +#[repr(C)] +pub struct DecodeError { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeDecodeError, + pub is_owned: bool, +} + +impl Drop for DecodeError { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn DecodeError_free(this_ptr: DecodeError) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn DecodeError_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDecodeError); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl DecodeError { + pub(crate) fn take_ptr(mut self) -> *mut nativeDecodeError { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::msgs::Init as nativeInitImport; +type nativeInit = nativeInitImport; + +/// An init message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct Init { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeInit, + pub is_owned: bool, +} + +impl Drop for Init { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn Init_free(this_ptr: Init) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn Init_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInit); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl Init { + pub(crate) fn take_ptr(mut self) -> *mut nativeInit { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::ln::msgs::ErrorMessage as nativeErrorMessageImport; +type nativeErrorMessage = nativeErrorMessageImport; + +/// An error message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct ErrorMessage { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeErrorMessage, + pub is_owned: bool, +} + +impl Drop for ErrorMessage { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ErrorMessage_free(this_ptr: ErrorMessage) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ErrorMessage_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeErrorMessage); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ErrorMessage { + pub(crate) fn take_ptr(mut self) -> *mut nativeErrorMessage { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ErrorMessage { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ErrorMessage_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeErrorMessage)).clone() })) as *mut c_void +} +/// The channel ID involved in the error +#[no_mangle] +pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID involved in the error +#[no_mangle] +pub extern "C" fn ErrorMessage_set_channel_id(this_ptr: &mut ErrorMessage, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// A possibly human-readable error description. +/// The string should be sanitized before it is used (e.g. emitted to logs +/// or printed to stdout). Otherwise, a well crafted error message may trigger a security +/// vulnerability in the terminal emulator or the logging subsystem. +#[no_mangle] +pub extern "C" fn ErrorMessage_get_data(this_ptr: &ErrorMessage) -> crate::c_types::Str { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.data; + (*inner_val).as_str().into() +} +/// A possibly human-readable error description. +/// The string should be sanitized before it is used (e.g. emitted to logs +/// or printed to stdout). Otherwise, a well crafted error message may trigger a security +/// vulnerability in the terminal emulator or the logging subsystem. +#[no_mangle] +pub extern "C" fn ErrorMessage_set_data(this_ptr: &mut ErrorMessage, mut val: crate::c_types::derived::CVec_u8Z) { + unsafe { &mut *this_ptr.inner }.data = String::from_utf8(val.into_rust()).unwrap(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn ErrorMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::derived::CVec_u8Z) -> ErrorMessage { + ErrorMessage { inner: Box::into_raw(Box::new(nativeErrorMessage { + channel_id: channel_id_arg.data, + data: String::from_utf8(data_arg.into_rust()).unwrap(), + })), is_owned: true } +} + +use lightning::ln::msgs::Ping as nativePingImport; +type nativePing = nativePingImport; + +/// A ping message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct Ping { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePing, + pub is_owned: bool, +} + +impl Drop for Ping { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn Ping_free(this_ptr: Ping) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn Ping_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePing); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl Ping { + pub(crate) fn take_ptr(mut self) -> *mut nativePing { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// The desired response length +#[no_mangle] +pub extern "C" fn Ping_get_ponglen(this_ptr: &Ping) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.ponglen; + (*inner_val) +} +/// The desired response length +#[no_mangle] +pub extern "C" fn Ping_set_ponglen(this_ptr: &mut Ping, mut val: u16) { + unsafe { &mut *this_ptr.inner }.ponglen = val; +} +/// The ping packet size. +/// This field is not sent on the wire. byteslen zeros are sent. +#[no_mangle] +pub extern "C" fn Ping_get_byteslen(this_ptr: &Ping) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.byteslen; + (*inner_val) +} +/// The ping packet size. +/// This field is not sent on the wire. byteslen zeros are sent. +#[no_mangle] +pub extern "C" fn Ping_set_byteslen(this_ptr: &mut Ping, mut val: u16) { + unsafe { &mut *this_ptr.inner }.byteslen = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn Ping_new(mut ponglen_arg: u16, mut byteslen_arg: u16) -> Ping { + Ping { inner: Box::into_raw(Box::new(nativePing { + ponglen: ponglen_arg, + byteslen: byteslen_arg, + })), is_owned: true } +} + +use lightning::ln::msgs::Pong as nativePongImport; +type nativePong = nativePongImport; + +/// A pong message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct Pong { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePong, + pub is_owned: bool, +} + +impl Drop for Pong { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn Pong_free(this_ptr: Pong) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn Pong_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePong); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl Pong { + pub(crate) fn take_ptr(mut self) -> *mut nativePong { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// The pong packet size. +/// This field is not sent on the wire. byteslen zeros are sent. +#[no_mangle] +pub extern "C" fn Pong_get_byteslen(this_ptr: &Pong) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.byteslen; + (*inner_val) +} +/// The pong packet size. +/// This field is not sent on the wire. byteslen zeros are sent. +#[no_mangle] +pub extern "C" fn Pong_set_byteslen(this_ptr: &mut Pong, mut val: u16) { + unsafe { &mut *this_ptr.inner }.byteslen = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn Pong_new(mut byteslen_arg: u16) -> Pong { + Pong { inner: Box::into_raw(Box::new(nativePong { + byteslen: byteslen_arg, + })), is_owned: true } +} + +use lightning::ln::msgs::OpenChannel as nativeOpenChannelImport; +type nativeOpenChannel = nativeOpenChannelImport; + +/// An open_channel message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct OpenChannel { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeOpenChannel, + pub is_owned: bool, +} + +impl Drop for OpenChannel { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn OpenChannel_free(this_ptr: OpenChannel) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeOpenChannel); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl OpenChannel { + pub(crate) fn take_ptr(mut self) -> *mut nativeOpenChannel { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for OpenChannel { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn OpenChannel_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOpenChannel)).clone() })) as *mut c_void +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn OpenChannel_get_chain_hash(this_ptr: &OpenChannel) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash; + (*inner_val).as_inner() +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn OpenChannel_set_chain_hash(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap(); +} +/// A temporary channel ID, until the funding outpoint is announced +#[no_mangle] +pub extern "C" fn OpenChannel_get_temporary_channel_id(this_ptr: &OpenChannel) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id; + &(*inner_val) +} +/// A temporary channel ID, until the funding outpoint is announced +#[no_mangle] +pub extern "C" fn OpenChannel_set_temporary_channel_id(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data; +} +/// The channel value +#[no_mangle] +pub extern "C" fn OpenChannel_get_funding_satoshis(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_satoshis; + (*inner_val) +} +/// The channel value +#[no_mangle] +pub extern "C" fn OpenChannel_set_funding_satoshis(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.funding_satoshis = val; +} +/// The amount to push to the counterparty as part of the open, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_get_push_msat(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.push_msat; + (*inner_val) +} +/// The amount to push to the counterparty as part of the open, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_set_push_msat(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.push_msat = val; +} +/// The threshold below which outputs on transactions broadcast by sender will be omitted +#[no_mangle] +pub extern "C" fn OpenChannel_get_dust_limit_satoshis(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.dust_limit_satoshis; + (*inner_val) +} +/// The threshold below which outputs on transactions broadcast by sender will be omitted +#[no_mangle] +pub extern "C" fn OpenChannel_set_dust_limit_satoshis(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.dust_limit_satoshis = val; +} +/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat; + (*inner_val) +} +/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat = val; +} +/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel +#[no_mangle] +pub extern "C" fn OpenChannel_get_channel_reserve_satoshis(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis; + (*inner_val) +} +/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel +#[no_mangle] +pub extern "C" fn OpenChannel_set_channel_reserve_satoshis(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis = val; +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_get_htlc_minimum_msat(this_ptr: &OpenChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat; + (*inner_val) +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn OpenChannel_set_htlc_minimum_msat(this_ptr: &mut OpenChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val; +} +/// The feerate per 1000-weight of sender generated transactions, until updated by update_fee +#[no_mangle] +pub extern "C" fn OpenChannel_get_feerate_per_kw(this_ptr: &OpenChannel) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.feerate_per_kw; + (*inner_val) +} +/// The feerate per 1000-weight of sender generated transactions, until updated by update_fee +#[no_mangle] +pub extern "C" fn OpenChannel_set_feerate_per_kw(this_ptr: &mut OpenChannel, mut val: u32) { + unsafe { &mut *this_ptr.inner }.feerate_per_kw = val; +} +/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction +#[no_mangle] +pub extern "C" fn OpenChannel_get_to_self_delay(this_ptr: &OpenChannel) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.to_self_delay; + (*inner_val) +} +/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction +#[no_mangle] +pub extern "C" fn OpenChannel_set_to_self_delay(this_ptr: &mut OpenChannel, mut val: u16) { + unsafe { &mut *this_ptr.inner }.to_self_delay = val; +} +/// The maximum number of inbound HTLCs towards sender +#[no_mangle] +pub extern "C" fn OpenChannel_get_max_accepted_htlcs(this_ptr: &OpenChannel) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_accepted_htlcs; + (*inner_val) +} +/// The maximum number of inbound HTLCs towards sender +#[no_mangle] +pub extern "C" fn OpenChannel_set_max_accepted_htlcs(this_ptr: &mut OpenChannel, mut val: u16) { + unsafe { &mut *this_ptr.inner }.max_accepted_htlcs = val; +} +/// The sender's key controlling the funding transaction +#[no_mangle] +pub extern "C" fn OpenChannel_get_funding_pubkey(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_pubkey; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The sender's key controlling the funding transaction +#[no_mangle] +pub extern "C" fn OpenChannel_set_funding_pubkey(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.funding_pubkey = val.into_rust(); +} +/// Used to derive a revocation key for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn OpenChannel_get_revocation_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive a revocation key for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn OpenChannel_set_revocation_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.revocation_basepoint = val.into_rust(); +} +/// A payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn OpenChannel_get_payment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// A payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn OpenChannel_set_payment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.payment_point = val.into_rust(); +} +/// Used to derive a payment key to sender for transactions broadcast by sender +#[no_mangle] +pub extern "C" fn OpenChannel_get_delayed_payment_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive a payment key to sender for transactions broadcast by sender +#[no_mangle] +pub extern "C" fn OpenChannel_set_delayed_payment_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint = val.into_rust(); +} +/// Used to derive an HTLC payment key to sender +#[no_mangle] +pub extern "C" fn OpenChannel_get_htlc_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive an HTLC payment key to sender +#[no_mangle] +pub extern "C" fn OpenChannel_set_htlc_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.htlc_basepoint = val.into_rust(); +} +/// The first to-be-broadcast-by-sender transaction's per commitment point +#[no_mangle] +pub extern "C" fn OpenChannel_get_first_per_commitment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The first to-be-broadcast-by-sender transaction's per commitment point +#[no_mangle] +pub extern "C" fn OpenChannel_set_first_per_commitment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.first_per_commitment_point = val.into_rust(); +} +/// Channel flags +#[no_mangle] +pub extern "C" fn OpenChannel_get_channel_flags(this_ptr: &OpenChannel) -> u8 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_flags; + (*inner_val) +} +/// Channel flags +#[no_mangle] +pub extern "C" fn OpenChannel_set_channel_flags(this_ptr: &mut OpenChannel, mut val: u8) { + unsafe { &mut *this_ptr.inner }.channel_flags = val; +} + +use lightning::ln::msgs::AcceptChannel as nativeAcceptChannelImport; +type nativeAcceptChannel = nativeAcceptChannelImport; + +/// An accept_channel message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct AcceptChannel { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeAcceptChannel, + pub is_owned: bool, +} + +impl Drop for AcceptChannel { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn AcceptChannel_free(this_ptr: AcceptChannel) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn AcceptChannel_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAcceptChannel); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl AcceptChannel { + pub(crate) fn take_ptr(mut self) -> *mut nativeAcceptChannel { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for AcceptChannel { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn AcceptChannel_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAcceptChannel)).clone() })) as *mut c_void +} +/// A temporary channel ID, until the funding outpoint is announced +#[no_mangle] +pub extern "C" fn AcceptChannel_get_temporary_channel_id(this_ptr: &AcceptChannel) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id; + &(*inner_val) +} +/// A temporary channel ID, until the funding outpoint is announced +#[no_mangle] +pub extern "C" fn AcceptChannel_set_temporary_channel_id(this_ptr: &mut AcceptChannel, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data; +} +/// The threshold below which outputs on transactions broadcast by sender will be omitted +#[no_mangle] +pub extern "C" fn AcceptChannel_get_dust_limit_satoshis(this_ptr: &AcceptChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.dust_limit_satoshis; + (*inner_val) +} +/// The threshold below which outputs on transactions broadcast by sender will be omitted +#[no_mangle] +pub extern "C" fn AcceptChannel_set_dust_limit_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.dust_limit_satoshis = val; +} +/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: &AcceptChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat; + (*inner_val) +} +/// The maximum inbound HTLC value in flight towards sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut AcceptChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat = val; +} +/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel +#[no_mangle] +pub extern "C" fn AcceptChannel_get_channel_reserve_satoshis(this_ptr: &AcceptChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis; + (*inner_val) +} +/// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel +#[no_mangle] +pub extern "C" fn AcceptChannel_set_channel_reserve_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis = val; +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn AcceptChannel_get_htlc_minimum_msat(this_ptr: &AcceptChannel) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat; + (*inner_val) +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn AcceptChannel_set_htlc_minimum_msat(this_ptr: &mut AcceptChannel, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val; +} +/// Minimum depth of the funding transaction before the channel is considered open +#[no_mangle] +pub extern "C" fn AcceptChannel_get_minimum_depth(this_ptr: &AcceptChannel) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.minimum_depth; + (*inner_val) +} +/// Minimum depth of the funding transaction before the channel is considered open +#[no_mangle] +pub extern "C" fn AcceptChannel_set_minimum_depth(this_ptr: &mut AcceptChannel, mut val: u32) { + unsafe { &mut *this_ptr.inner }.minimum_depth = val; +} +/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction +#[no_mangle] +pub extern "C" fn AcceptChannel_get_to_self_delay(this_ptr: &AcceptChannel) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.to_self_delay; + (*inner_val) +} +/// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction +#[no_mangle] +pub extern "C" fn AcceptChannel_set_to_self_delay(this_ptr: &mut AcceptChannel, mut val: u16) { + unsafe { &mut *this_ptr.inner }.to_self_delay = val; +} +/// The maximum number of inbound HTLCs towards sender +#[no_mangle] +pub extern "C" fn AcceptChannel_get_max_accepted_htlcs(this_ptr: &AcceptChannel) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_accepted_htlcs; + (*inner_val) +} +/// The maximum number of inbound HTLCs towards sender +#[no_mangle] +pub extern "C" fn AcceptChannel_set_max_accepted_htlcs(this_ptr: &mut AcceptChannel, mut val: u16) { + unsafe { &mut *this_ptr.inner }.max_accepted_htlcs = val; +} +/// The sender's key controlling the funding transaction +#[no_mangle] +pub extern "C" fn AcceptChannel_get_funding_pubkey(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_pubkey; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The sender's key controlling the funding transaction +#[no_mangle] +pub extern "C" fn AcceptChannel_set_funding_pubkey(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.funding_pubkey = val.into_rust(); +} +/// Used to derive a revocation key for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_get_revocation_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive a revocation key for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_set_revocation_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.revocation_basepoint = val.into_rust(); +} +/// A payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_get_payment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// A payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_set_payment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.payment_point = val.into_rust(); +} +/// Used to derive a payment key to sender for transactions broadcast by sender +#[no_mangle] +pub extern "C" fn AcceptChannel_get_delayed_payment_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive a payment key to sender for transactions broadcast by sender +#[no_mangle] +pub extern "C" fn AcceptChannel_set_delayed_payment_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint = val.into_rust(); +} +/// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_get_htlc_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_basepoint; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty +#[no_mangle] +pub extern "C" fn AcceptChannel_set_htlc_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.htlc_basepoint = val.into_rust(); +} +/// The first to-be-broadcast-by-sender transaction's per commitment point +#[no_mangle] +pub extern "C" fn AcceptChannel_get_first_per_commitment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The first to-be-broadcast-by-sender transaction's per commitment point +#[no_mangle] +pub extern "C" fn AcceptChannel_set_first_per_commitment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.first_per_commitment_point = val.into_rust(); +} + +use lightning::ln::msgs::FundingCreated as nativeFundingCreatedImport; +type nativeFundingCreated = nativeFundingCreatedImport; + +/// A funding_created message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct FundingCreated { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeFundingCreated, + pub is_owned: bool, +} + +impl Drop for FundingCreated { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn FundingCreated_free(this_ptr: FundingCreated) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingCreated); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl FundingCreated { + pub(crate) fn take_ptr(mut self) -> *mut nativeFundingCreated { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for FundingCreated { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn FundingCreated_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingCreated)).clone() })) as *mut c_void +} +/// A temporary channel ID, until the funding is established +#[no_mangle] +pub extern "C" fn FundingCreated_get_temporary_channel_id(this_ptr: &FundingCreated) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id; + &(*inner_val) +} +/// A temporary channel ID, until the funding is established +#[no_mangle] +pub extern "C" fn FundingCreated_set_temporary_channel_id(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data; +} +/// The funding transaction ID +#[no_mangle] +pub extern "C" fn FundingCreated_get_funding_txid(this_ptr: &FundingCreated) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_txid; + (*inner_val).as_inner() +} +/// The funding transaction ID +#[no_mangle] +pub extern "C" fn FundingCreated_set_funding_txid(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.funding_txid = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap(); +} +/// The specific output index funding this channel +#[no_mangle] +pub extern "C" fn FundingCreated_get_funding_output_index(this_ptr: &FundingCreated) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_output_index; + (*inner_val) +} +/// The specific output index funding this channel +#[no_mangle] +pub extern "C" fn FundingCreated_set_funding_output_index(this_ptr: &mut FundingCreated, mut val: u16) { + unsafe { &mut *this_ptr.inner }.funding_output_index = val; +} +/// The signature of the channel initiator (funder) on the funding transaction +#[no_mangle] +pub extern "C" fn FundingCreated_get_signature(this_ptr: &FundingCreated) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// The signature of the channel initiator (funder) on the funding transaction +#[no_mangle] +pub extern "C" fn FundingCreated_set_signature(this_ptr: &mut FundingCreated, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn FundingCreated_new(mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_txid_arg: crate::c_types::ThirtyTwoBytes, mut funding_output_index_arg: u16, mut signature_arg: crate::c_types::Signature) -> FundingCreated { + FundingCreated { inner: Box::into_raw(Box::new(nativeFundingCreated { + temporary_channel_id: temporary_channel_id_arg.data, + funding_txid: ::bitcoin::hash_types::Txid::from_slice(&funding_txid_arg.data[..]).unwrap(), + funding_output_index: funding_output_index_arg, + signature: signature_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::FundingSigned as nativeFundingSignedImport; +type nativeFundingSigned = nativeFundingSignedImport; + +/// A funding_signed message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct FundingSigned { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeFundingSigned, + pub is_owned: bool, +} + +impl Drop for FundingSigned { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn FundingSigned_free(this_ptr: FundingSigned) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn FundingSigned_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingSigned); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl FundingSigned { + pub(crate) fn take_ptr(mut self) -> *mut nativeFundingSigned { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for FundingSigned { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn FundingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingSigned)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn FundingSigned_set_channel_id(this_ptr: &mut FundingSigned, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The signature of the channel acceptor (fundee) on the funding transaction +#[no_mangle] +pub extern "C" fn FundingSigned_get_signature(this_ptr: &FundingSigned) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// The signature of the channel acceptor (fundee) on the funding transaction +#[no_mangle] +pub extern "C" fn FundingSigned_set_signature(this_ptr: &mut FundingSigned, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn FundingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::Signature) -> FundingSigned { + FundingSigned { inner: Box::into_raw(Box::new(nativeFundingSigned { + channel_id: channel_id_arg.data, + signature: signature_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::FundingLocked as nativeFundingLockedImport; +type nativeFundingLocked = nativeFundingLockedImport; + +/// A funding_locked message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct FundingLocked { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeFundingLocked, + pub is_owned: bool, +} + +impl Drop for FundingLocked { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn FundingLocked_free(this_ptr: FundingLocked) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn FundingLocked_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingLocked); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl FundingLocked { + pub(crate) fn take_ptr(mut self) -> *mut nativeFundingLocked { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for FundingLocked { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn FundingLocked_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingLocked)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn FundingLocked_get_channel_id(this_ptr: &FundingLocked) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn FundingLocked_set_channel_id(this_ptr: &mut FundingLocked, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The per-commitment point of the second commitment transaction +#[no_mangle] +pub extern "C" fn FundingLocked_get_next_per_commitment_point(this_ptr: &FundingLocked) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The per-commitment point of the second commitment transaction +#[no_mangle] +pub extern "C" fn FundingLocked_set_next_per_commitment_point(this_ptr: &mut FundingLocked, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.next_per_commitment_point = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn FundingLocked_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> FundingLocked { + FundingLocked { inner: Box::into_raw(Box::new(nativeFundingLocked { + channel_id: channel_id_arg.data, + next_per_commitment_point: next_per_commitment_point_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::Shutdown as nativeShutdownImport; +type nativeShutdown = nativeShutdownImport; + +/// A shutdown message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct Shutdown { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeShutdown, + pub is_owned: bool, +} + +impl Drop for Shutdown { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn Shutdown_free(this_ptr: Shutdown) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeShutdown); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl Shutdown { + pub(crate) fn take_ptr(mut self) -> *mut nativeShutdown { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for Shutdown { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Shutdown_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeShutdown)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn Shutdown_set_channel_id(this_ptr: &mut Shutdown, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The destination of this peer's funds on closing. +/// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh. +#[no_mangle] +pub extern "C" fn Shutdown_get_scriptpubkey(this_ptr: &Shutdown) -> crate::c_types::u8slice { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.scriptpubkey; + crate::c_types::u8slice::from_slice(&(*inner_val)[..]) +} +/// The destination of this peer's funds on closing. +/// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh. +#[no_mangle] +pub extern "C" fn Shutdown_set_scriptpubkey(this_ptr: &mut Shutdown, mut val: crate::c_types::derived::CVec_u8Z) { + unsafe { &mut *this_ptr.inner }.scriptpubkey = ::bitcoin::blockdata::script::Script::from(val.into_rust()); +} +#[must_use] +#[no_mangle] +pub extern "C" fn Shutdown_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut scriptpubkey_arg: crate::c_types::derived::CVec_u8Z) -> Shutdown { + Shutdown { inner: Box::into_raw(Box::new(nativeShutdown { + channel_id: channel_id_arg.data, + scriptpubkey: ::bitcoin::blockdata::script::Script::from(scriptpubkey_arg.into_rust()), + })), is_owned: true } +} + +use lightning::ln::msgs::ClosingSigned as nativeClosingSignedImport; +type nativeClosingSigned = nativeClosingSignedImport; + +/// A closing_signed message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct ClosingSigned { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeClosingSigned, + pub is_owned: bool, +} + +impl Drop for ClosingSigned { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ClosingSigned_free(this_ptr: ClosingSigned) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeClosingSigned); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ClosingSigned { + pub(crate) fn take_ptr(mut self) -> *mut nativeClosingSigned { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ClosingSigned { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ClosingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSigned)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn ClosingSigned_set_channel_id(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The proposed total fee for the closing transaction +#[no_mangle] +pub extern "C" fn ClosingSigned_get_fee_satoshis(this_ptr: &ClosingSigned) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_satoshis; + (*inner_val) +} +/// The proposed total fee for the closing transaction +#[no_mangle] +pub extern "C" fn ClosingSigned_set_fee_satoshis(this_ptr: &mut ClosingSigned, mut val: u64) { + unsafe { &mut *this_ptr.inner }.fee_satoshis = val; +} +/// A signature on the closing transaction +#[no_mangle] +pub extern "C" fn ClosingSigned_get_signature(this_ptr: &ClosingSigned) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// A signature on the closing transaction +#[no_mangle] +pub extern "C" fn ClosingSigned_set_signature(this_ptr: &mut ClosingSigned, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn ClosingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut fee_satoshis_arg: u64, mut signature_arg: crate::c_types::Signature) -> ClosingSigned { + ClosingSigned { inner: Box::into_raw(Box::new(nativeClosingSigned { + channel_id: channel_id_arg.data, + fee_satoshis: fee_satoshis_arg, + signature: signature_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::UpdateAddHTLC as nativeUpdateAddHTLCImport; +type nativeUpdateAddHTLC = nativeUpdateAddHTLCImport; + +/// An update_add_htlc message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct UpdateAddHTLC { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUpdateAddHTLC, + pub is_owned: bool, +} + +impl Drop for UpdateAddHTLC { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_free(this_ptr: UpdateAddHTLC) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateAddHTLC); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UpdateAddHTLC { + pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateAddHTLC { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UpdateAddHTLC { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UpdateAddHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateAddHTLC)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_set_channel_id(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_get_htlc_id(this_ptr: &UpdateAddHTLC) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id; + (*inner_val) +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_set_htlc_id(this_ptr: &mut UpdateAddHTLC, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_id = val; +} +/// The HTLC value in milli-satoshi +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_get_amount_msat(this_ptr: &UpdateAddHTLC) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.amount_msat; + (*inner_val) +} +/// The HTLC value in milli-satoshi +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_set_amount_msat(this_ptr: &mut UpdateAddHTLC, mut val: u64) { + unsafe { &mut *this_ptr.inner }.amount_msat = val; +} +/// The payment hash, the pre-image of which controls HTLC redemption +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_get_payment_hash(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_hash; + &(*inner_val).0 +} +/// The payment hash, the pre-image of which controls HTLC redemption +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_set_payment_hash(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.payment_hash = ::lightning::ln::channelmanager::PaymentHash(val.data); +} +/// The expiry height of the HTLC +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_get_cltv_expiry(this_ptr: &UpdateAddHTLC) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry; + (*inner_val) +} +/// The expiry height of the HTLC +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_set_cltv_expiry(this_ptr: &mut UpdateAddHTLC, mut val: u32) { + unsafe { &mut *this_ptr.inner }.cltv_expiry = val; +} + +use lightning::ln::msgs::UpdateFulfillHTLC as nativeUpdateFulfillHTLCImport; +type nativeUpdateFulfillHTLC = nativeUpdateFulfillHTLCImport; + +/// An update_fulfill_htlc message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct UpdateFulfillHTLC { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUpdateFulfillHTLC, + pub is_owned: bool, +} + +impl Drop for UpdateFulfillHTLC { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_free(this_ptr: UpdateFulfillHTLC) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFulfillHTLC); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UpdateFulfillHTLC { + pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFulfillHTLC { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UpdateFulfillHTLC { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UpdateFulfillHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFulfillHTLC)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_set_channel_id(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_get_htlc_id(this_ptr: &UpdateFulfillHTLC) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id; + (*inner_val) +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_set_htlc_id(this_ptr: &mut UpdateFulfillHTLC, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_id = val; +} +/// The pre-image of the payment hash, allowing HTLC redemption +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_get_payment_preimage(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_preimage; + &(*inner_val).0 +} +/// The pre-image of the payment hash, allowing HTLC redemption +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_set_payment_preimage(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.payment_preimage = ::lightning::ln::channelmanager::PaymentPreimage(val.data); +} +#[must_use] +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut htlc_id_arg: u64, mut payment_preimage_arg: crate::c_types::ThirtyTwoBytes) -> UpdateFulfillHTLC { + UpdateFulfillHTLC { inner: Box::into_raw(Box::new(nativeUpdateFulfillHTLC { + channel_id: channel_id_arg.data, + htlc_id: htlc_id_arg, + payment_preimage: ::lightning::ln::channelmanager::PaymentPreimage(payment_preimage_arg.data), + })), is_owned: true } +} + +use lightning::ln::msgs::UpdateFailHTLC as nativeUpdateFailHTLCImport; +type nativeUpdateFailHTLC = nativeUpdateFailHTLCImport; + +/// An update_fail_htlc message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct UpdateFailHTLC { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUpdateFailHTLC, + pub is_owned: bool, +} + +impl Drop for UpdateFailHTLC { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_free(this_ptr: UpdateFailHTLC) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailHTLC); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UpdateFailHTLC { + pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFailHTLC { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UpdateFailHTLC { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UpdateFailHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailHTLC)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_set_channel_id(this_ptr: &mut UpdateFailHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_get_htlc_id(this_ptr: &UpdateFailHTLC) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id; + (*inner_val) +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_set_htlc_id(this_ptr: &mut UpdateFailHTLC, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_id = val; +} + +use lightning::ln::msgs::UpdateFailMalformedHTLC as nativeUpdateFailMalformedHTLCImport; +type nativeUpdateFailMalformedHTLC = nativeUpdateFailMalformedHTLCImport; + +/// An update_fail_malformed_htlc message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct UpdateFailMalformedHTLC { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUpdateFailMalformedHTLC, + pub is_owned: bool, +} + +impl Drop for UpdateFailMalformedHTLC { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_free(this_ptr: UpdateFailMalformedHTLC) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailMalformedHTLC); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UpdateFailMalformedHTLC { + pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFailMalformedHTLC { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UpdateFailMalformedHTLC { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UpdateFailMalformedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_set_channel_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_get_htlc_id(this_ptr: &UpdateFailMalformedHTLC) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id; + (*inner_val) +} +/// The HTLC ID +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_set_htlc_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_id = val; +} +/// The failure code +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_get_failure_code(this_ptr: &UpdateFailMalformedHTLC) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.failure_code; + (*inner_val) +} +/// The failure code +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_set_failure_code(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u16) { + unsafe { &mut *this_ptr.inner }.failure_code = val; +} + +use lightning::ln::msgs::CommitmentSigned as nativeCommitmentSignedImport; +type nativeCommitmentSigned = nativeCommitmentSignedImport; + +/// A commitment_signed message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct CommitmentSigned { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeCommitmentSigned, + pub is_owned: bool, +} + +impl Drop for CommitmentSigned { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn CommitmentSigned_free(this_ptr: CommitmentSigned) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentSigned); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl CommitmentSigned { + pub(crate) fn take_ptr(mut self) -> *mut nativeCommitmentSigned { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for CommitmentSigned { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn CommitmentSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentSigned)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn CommitmentSigned_set_channel_id(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// A signature on the commitment transaction +#[no_mangle] +pub extern "C" fn CommitmentSigned_get_signature(this_ptr: &CommitmentSigned) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// A signature on the commitment transaction +#[no_mangle] +pub extern "C" fn CommitmentSigned_set_signature(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +/// Signatures on the HTLC transactions +#[no_mangle] +pub extern "C" fn CommitmentSigned_set_htlc_signatures(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::derived::CVec_SignatureZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_rust() }); }; + unsafe { &mut *this_ptr.inner }.htlc_signatures = local_val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn CommitmentSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::Signature, mut htlc_signatures_arg: crate::c_types::derived::CVec_SignatureZ) -> CommitmentSigned { + let mut local_htlc_signatures_arg = Vec::new(); for mut item in htlc_signatures_arg.into_rust().drain(..) { local_htlc_signatures_arg.push( { item.into_rust() }); }; + CommitmentSigned { inner: Box::into_raw(Box::new(nativeCommitmentSigned { + channel_id: channel_id_arg.data, + signature: signature_arg.into_rust(), + htlc_signatures: local_htlc_signatures_arg, + })), is_owned: true } +} + +use lightning::ln::msgs::RevokeAndACK as nativeRevokeAndACKImport; +type nativeRevokeAndACK = nativeRevokeAndACKImport; + +/// A revoke_and_ack message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct RevokeAndACK { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeRevokeAndACK, + pub is_owned: bool, +} + +impl Drop for RevokeAndACK { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn RevokeAndACK_free(this_ptr: RevokeAndACK) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRevokeAndACK); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl RevokeAndACK { + pub(crate) fn take_ptr(mut self) -> *mut nativeRevokeAndACK { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for RevokeAndACK { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRevokeAndACK)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn RevokeAndACK_set_channel_id(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The secret corresponding to the per-commitment point +#[no_mangle] +pub extern "C" fn RevokeAndACK_get_per_commitment_secret(this_ptr: &RevokeAndACK) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.per_commitment_secret; + &(*inner_val) +} +/// The secret corresponding to the per-commitment point +#[no_mangle] +pub extern "C" fn RevokeAndACK_set_per_commitment_secret(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.per_commitment_secret = val.data; +} +/// The next sender-broadcast commitment transaction's per-commitment point +#[no_mangle] +pub extern "C" fn RevokeAndACK_get_next_per_commitment_point(this_ptr: &RevokeAndACK) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The next sender-broadcast commitment transaction's per-commitment point +#[no_mangle] +pub extern "C" fn RevokeAndACK_set_next_per_commitment_point(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.next_per_commitment_point = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn RevokeAndACK_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> RevokeAndACK { + RevokeAndACK { inner: Box::into_raw(Box::new(nativeRevokeAndACK { + channel_id: channel_id_arg.data, + per_commitment_secret: per_commitment_secret_arg.data, + next_per_commitment_point: next_per_commitment_point_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::UpdateFee as nativeUpdateFeeImport; +type nativeUpdateFee = nativeUpdateFeeImport; + +/// An update_fee message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct UpdateFee { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUpdateFee, + pub is_owned: bool, +} + +impl Drop for UpdateFee { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UpdateFee_free(this_ptr: UpdateFee) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFee); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UpdateFee { + pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFee { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UpdateFee { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFee)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn UpdateFee_set_channel_id(this_ptr: &mut UpdateFee, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// Fee rate per 1000-weight of the transaction +#[no_mangle] +pub extern "C" fn UpdateFee_get_feerate_per_kw(this_ptr: &UpdateFee) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.feerate_per_kw; + (*inner_val) +} +/// Fee rate per 1000-weight of the transaction +#[no_mangle] +pub extern "C" fn UpdateFee_set_feerate_per_kw(this_ptr: &mut UpdateFee, mut val: u32) { + unsafe { &mut *this_ptr.inner }.feerate_per_kw = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn UpdateFee_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut feerate_per_kw_arg: u32) -> UpdateFee { + UpdateFee { inner: Box::into_raw(Box::new(nativeUpdateFee { + channel_id: channel_id_arg.data, + feerate_per_kw: feerate_per_kw_arg, + })), is_owned: true } +} + +use lightning::ln::msgs::DataLossProtect as nativeDataLossProtectImport; +type nativeDataLossProtect = nativeDataLossProtectImport; + +/// Proof that the sender knows the per-commitment secret of the previous commitment transaction. +/// This is used to convince the recipient that the channel is at a certain commitment +/// number even if they lost that data due to a local failure. Of course, the peer may lie +/// and even later commitments may have been revoked. +#[must_use] +#[repr(C)] +pub struct DataLossProtect { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeDataLossProtect, + pub is_owned: bool, +} + +impl Drop for DataLossProtect { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn DataLossProtect_free(this_ptr: DataLossProtect) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn DataLossProtect_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDataLossProtect); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl DataLossProtect { + pub(crate) fn take_ptr(mut self) -> *mut nativeDataLossProtect { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for DataLossProtect { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn DataLossProtect_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDataLossProtect)).clone() })) as *mut c_void +} +/// Proof that the sender knows the per-commitment secret of a specific commitment transaction +/// belonging to the recipient +#[no_mangle] +pub extern "C" fn DataLossProtect_get_your_last_per_commitment_secret(this_ptr: &DataLossProtect) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.your_last_per_commitment_secret; + &(*inner_val) +} +/// Proof that the sender knows the per-commitment secret of a specific commitment transaction +/// belonging to the recipient +#[no_mangle] +pub extern "C" fn DataLossProtect_set_your_last_per_commitment_secret(this_ptr: &mut DataLossProtect, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.your_last_per_commitment_secret = val.data; +} +/// The sender's per-commitment point for their current commitment transaction +#[no_mangle] +pub extern "C" fn DataLossProtect_get_my_current_per_commitment_point(this_ptr: &DataLossProtect) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.my_current_per_commitment_point; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The sender's per-commitment point for their current commitment transaction +#[no_mangle] +pub extern "C" fn DataLossProtect_set_my_current_per_commitment_point(this_ptr: &mut DataLossProtect, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.my_current_per_commitment_point = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn DataLossProtect_new(mut your_last_per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut my_current_per_commitment_point_arg: crate::c_types::PublicKey) -> DataLossProtect { + DataLossProtect { inner: Box::into_raw(Box::new(nativeDataLossProtect { + your_last_per_commitment_secret: your_last_per_commitment_secret_arg.data, + my_current_per_commitment_point: my_current_per_commitment_point_arg.into_rust(), + })), is_owned: true } +} + +use lightning::ln::msgs::ChannelReestablish as nativeChannelReestablishImport; +type nativeChannelReestablish = nativeChannelReestablishImport; + +/// A channel_reestablish message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct ChannelReestablish { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelReestablish, + pub is_owned: bool, +} + +impl Drop for ChannelReestablish { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelReestablish_free(this_ptr: ChannelReestablish) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelReestablish); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelReestablish { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelReestablish { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelReestablish { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelReestablish)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn ChannelReestablish_set_channel_id(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The next commitment number for the sender +#[no_mangle] +pub extern "C" fn ChannelReestablish_get_next_local_commitment_number(this_ptr: &ChannelReestablish) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_local_commitment_number; + (*inner_val) +} +/// The next commitment number for the sender +#[no_mangle] +pub extern "C" fn ChannelReestablish_set_next_local_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) { + unsafe { &mut *this_ptr.inner }.next_local_commitment_number = val; +} +/// The next commitment number for the recipient +#[no_mangle] +pub extern "C" fn ChannelReestablish_get_next_remote_commitment_number(this_ptr: &ChannelReestablish) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_remote_commitment_number; + (*inner_val) +} +/// The next commitment number for the recipient +#[no_mangle] +pub extern "C" fn ChannelReestablish_set_next_remote_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) { + unsafe { &mut *this_ptr.inner }.next_remote_commitment_number = val; +} + +use lightning::ln::msgs::AnnouncementSignatures as nativeAnnouncementSignaturesImport; +type nativeAnnouncementSignatures = nativeAnnouncementSignaturesImport; + +/// An announcement_signatures message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct AnnouncementSignatures { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeAnnouncementSignatures, + pub is_owned: bool, +} + +impl Drop for AnnouncementSignatures { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_free(this_ptr: AnnouncementSignatures) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAnnouncementSignatures); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl AnnouncementSignatures { + pub(crate) fn take_ptr(mut self) -> *mut nativeAnnouncementSignatures { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for AnnouncementSignatures { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAnnouncementSignatures)).clone() })) as *mut c_void +} +/// The channel ID +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id; + &(*inner_val) +} +/// The channel ID +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_set_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.channel_id = val.data; +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_get_short_channel_id(this_ptr: &AnnouncementSignatures) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id; + (*inner_val) +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_set_short_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: u64) { + unsafe { &mut *this_ptr.inner }.short_channel_id = val; +} +/// A signature by the node key +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_get_node_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// A signature by the node key +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_set_node_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.node_signature = val.into_rust(); +} +/// A signature by the funding key +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_get_bitcoin_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// A signature by the funding key +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_set_bitcoin_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.bitcoin_signature = val.into_rust(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_id_arg: u64, mut node_signature_arg: crate::c_types::Signature, mut bitcoin_signature_arg: crate::c_types::Signature) -> AnnouncementSignatures { + AnnouncementSignatures { inner: Box::into_raw(Box::new(nativeAnnouncementSignatures { + channel_id: channel_id_arg.data, + short_channel_id: short_channel_id_arg, + node_signature: node_signature_arg.into_rust(), + bitcoin_signature: bitcoin_signature_arg.into_rust(), + })), is_owned: true } +} +/// An address which can be used to connect to a remote peer +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum NetAddress { + /// An IPv4 address/port on which the peer is listening. + IPv4 { + addr: crate::c_types::FourBytes, + port: u16, + }, + /// An IPv6 address/port on which the peer is listening. + IPv6 { + addr: crate::c_types::SixteenBytes, + port: u16, + }, + /// An old-style Tor onion address/port on which the peer is listening. + OnionV2 { + addr: crate::c_types::TenBytes, + port: u16, + }, + /// A new-style Tor onion address/port on which the peer is listening. + /// To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version, + /// wrap as base32 and append \".onion\". + OnionV3 { + ed25519_pubkey: crate::c_types::ThirtyTwoBytes, + checksum: u16, + version: u8, + port: u16, + }, +} +use lightning::ln::msgs::NetAddress as nativeNetAddress; +impl NetAddress { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeNetAddress { + match self { + NetAddress::IPv4 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + nativeNetAddress::IPv4 { + addr: addr_nonref.data, + port: port_nonref, + } + }, + NetAddress::IPv6 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + nativeNetAddress::IPv6 { + addr: addr_nonref.data, + port: port_nonref, + } + }, + NetAddress::OnionV2 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + nativeNetAddress::OnionV2 { + addr: addr_nonref.data, + port: port_nonref, + } + }, + NetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => { + let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone(); + let mut checksum_nonref = (*checksum).clone(); + let mut version_nonref = (*version).clone(); + let mut port_nonref = (*port).clone(); + nativeNetAddress::OnionV3 { + ed25519_pubkey: ed25519_pubkey_nonref.data, + checksum: checksum_nonref, + version: version_nonref, + port: port_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeNetAddress { + match self { + NetAddress::IPv4 {mut addr, mut port, } => { + nativeNetAddress::IPv4 { + addr: addr.data, + port: port, + } + }, + NetAddress::IPv6 {mut addr, mut port, } => { + nativeNetAddress::IPv6 { + addr: addr.data, + port: port, + } + }, + NetAddress::OnionV2 {mut addr, mut port, } => { + nativeNetAddress::OnionV2 { + addr: addr.data, + port: port, + } + }, + NetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => { + nativeNetAddress::OnionV3 { + ed25519_pubkey: ed25519_pubkey.data, + checksum: checksum, + version: version, + port: port, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeNetAddress) -> Self { + match native { + nativeNetAddress::IPv4 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + NetAddress::IPv4 { + addr: crate::c_types::FourBytes { data: addr_nonref }, + port: port_nonref, + } + }, + nativeNetAddress::IPv6 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + NetAddress::IPv6 { + addr: crate::c_types::SixteenBytes { data: addr_nonref }, + port: port_nonref, + } + }, + nativeNetAddress::OnionV2 {ref addr, ref port, } => { + let mut addr_nonref = (*addr).clone(); + let mut port_nonref = (*port).clone(); + NetAddress::OnionV2 { + addr: crate::c_types::TenBytes { data: addr_nonref }, + port: port_nonref, + } + }, + nativeNetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => { + let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone(); + let mut checksum_nonref = (*checksum).clone(); + let mut version_nonref = (*version).clone(); + let mut port_nonref = (*port).clone(); + NetAddress::OnionV3 { + ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey_nonref }, + checksum: checksum_nonref, + version: version_nonref, + port: port_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeNetAddress) -> Self { + match native { + nativeNetAddress::IPv4 {mut addr, mut port, } => { + NetAddress::IPv4 { + addr: crate::c_types::FourBytes { data: addr }, + port: port, + } + }, + nativeNetAddress::IPv6 {mut addr, mut port, } => { + NetAddress::IPv6 { + addr: crate::c_types::SixteenBytes { data: addr }, + port: port, + } + }, + nativeNetAddress::OnionV2 {mut addr, mut port, } => { + NetAddress::OnionV2 { + addr: crate::c_types::TenBytes { data: addr }, + port: port, + } + }, + nativeNetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => { + NetAddress::OnionV3 { + ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey }, + checksum: checksum, + version: version, + port: port, + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn NetAddress_free(this_ptr: NetAddress) { } + +use lightning::ln::msgs::UnsignedNodeAnnouncement as nativeUnsignedNodeAnnouncementImport; +type nativeUnsignedNodeAnnouncement = nativeUnsignedNodeAnnouncementImport; + +/// The unsigned part of a node_announcement +#[must_use] +#[repr(C)] +pub struct UnsignedNodeAnnouncement { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUnsignedNodeAnnouncement, + pub is_owned: bool, +} + +impl Drop for UnsignedNodeAnnouncement { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_free(this_ptr: UnsignedNodeAnnouncement) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UnsignedNodeAnnouncement_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedNodeAnnouncement); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UnsignedNodeAnnouncement { + pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedNodeAnnouncement { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UnsignedNodeAnnouncement { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UnsignedNodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedNodeAnnouncement)).clone() })) as *mut c_void +} +/// A strictly monotonic announcement counter, with gaps allowed +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_get_timestamp(this_ptr: &UnsignedNodeAnnouncement) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.timestamp; + (*inner_val) +} +/// A strictly monotonic announcement counter, with gaps allowed +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_set_timestamp(this_ptr: &mut UnsignedNodeAnnouncement, mut val: u32) { + unsafe { &mut *this_ptr.inner }.timestamp = val; +} +/// The node_id this announcement originated from (don't rebroadcast the node_announcement back +/// to this node). +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_get_node_id(this_ptr: &UnsignedNodeAnnouncement) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The node_id this announcement originated from (don't rebroadcast the node_announcement back +/// to this node). +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_set_node_id(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.node_id = val.into_rust(); +} +/// An RGB color for UI purposes +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_get_rgb(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 3] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.rgb; + &(*inner_val) +} +/// An RGB color for UI purposes +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_set_rgb(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThreeBytes) { + unsafe { &mut *this_ptr.inner }.rgb = val.data; +} +/// An alias, for UI purposes. This should be sanitized before use. There is no guarantee +/// of uniqueness. +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_get_alias(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.alias; + &(*inner_val) +} +/// An alias, for UI purposes. This should be sanitized before use. There is no guarantee +/// of uniqueness. +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_set_alias(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.alias = val.data; +} +/// List of addresses on which this node is reachable +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_set_addresses(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::derived::CVec_NetAddressZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_native() }); }; + unsafe { &mut *this_ptr.inner }.addresses = local_val; +} + +use lightning::ln::msgs::NodeAnnouncement as nativeNodeAnnouncementImport; +type nativeNodeAnnouncement = nativeNodeAnnouncementImport; + +/// A node_announcement message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct NodeAnnouncement { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNodeAnnouncement, + pub is_owned: bool, +} + +impl Drop for NodeAnnouncement { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NodeAnnouncement_free(this_ptr: NodeAnnouncement) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NodeAnnouncement_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeAnnouncement); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NodeAnnouncement { + pub(crate) fn take_ptr(mut self) -> *mut nativeNodeAnnouncement { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for NodeAnnouncement { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn NodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeNodeAnnouncement)).clone() })) as *mut c_void +} +/// The signature by the node key +#[no_mangle] +pub extern "C" fn NodeAnnouncement_get_signature(this_ptr: &NodeAnnouncement) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// The signature by the node key +#[no_mangle] +pub extern "C" fn NodeAnnouncement_set_signature(this_ptr: &mut NodeAnnouncement, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +/// The actual content of the announcement +#[no_mangle] +pub extern "C" fn NodeAnnouncement_get_contents(this_ptr: &NodeAnnouncement) -> crate::ln::msgs::UnsignedNodeAnnouncement { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents; + crate::ln::msgs::UnsignedNodeAnnouncement { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// The actual content of the announcement +#[no_mangle] +pub extern "C" fn NodeAnnouncement_set_contents(this_ptr: &mut NodeAnnouncement, mut val: crate::ln::msgs::UnsignedNodeAnnouncement) { + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; +} +#[must_use] +#[no_mangle] +pub extern "C" fn NodeAnnouncement_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::ln::msgs::UnsignedNodeAnnouncement) -> NodeAnnouncement { + NodeAnnouncement { inner: Box::into_raw(Box::new(nativeNodeAnnouncement { + signature: signature_arg.into_rust(), + contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + })), is_owned: true } +} + +use lightning::ln::msgs::UnsignedChannelAnnouncement as nativeUnsignedChannelAnnouncementImport; +type nativeUnsignedChannelAnnouncement = nativeUnsignedChannelAnnouncementImport; + +/// The unsigned part of a channel_announcement +#[must_use] +#[repr(C)] +pub struct UnsignedChannelAnnouncement { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUnsignedChannelAnnouncement, + pub is_owned: bool, +} + +impl Drop for UnsignedChannelAnnouncement { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_free(this_ptr: UnsignedChannelAnnouncement) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UnsignedChannelAnnouncement_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelAnnouncement); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UnsignedChannelAnnouncement { + pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedChannelAnnouncement { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UnsignedChannelAnnouncement { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UnsignedChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelAnnouncement)).clone() })) as *mut c_void +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_chain_hash(this_ptr: &UnsignedChannelAnnouncement) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash; + (*inner_val).as_inner() +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_chain_hash(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap(); +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: &UnsignedChannelAnnouncement) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id; + (*inner_val) +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: &mut UnsignedChannelAnnouncement, mut val: u64) { + unsafe { &mut *this_ptr.inner }.short_channel_id = val; +} +/// One of the two node_ids which are endpoints of this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id_1; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// One of the two node_ids which are endpoints of this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.node_id_1 = val.into_rust(); +} +/// The other of the two node_ids which are endpoints of this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id_2; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The other of the two node_ids which are endpoints of this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.node_id_2 = val.into_rust(); +} +/// The funding key for the first node +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_key_1; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The funding key for the first node +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.bitcoin_key_1 = val.into_rust(); +} +/// The funding key for the second node +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_key_2; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The funding key for the second node +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.bitcoin_key_2 = val.into_rust(); +} + +use lightning::ln::msgs::ChannelAnnouncement as nativeChannelAnnouncementImport; +type nativeChannelAnnouncement = nativeChannelAnnouncementImport; + +/// A channel_announcement message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct ChannelAnnouncement { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelAnnouncement, + pub is_owned: bool, +} + +impl Drop for ChannelAnnouncement { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_free(this_ptr: ChannelAnnouncement) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelAnnouncement_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelAnnouncement); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelAnnouncement { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelAnnouncement { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelAnnouncement { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelAnnouncement)).clone() })) as *mut c_void +} +/// Authentication of the announcement by the first public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_get_node_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature_1; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// Authentication of the announcement by the first public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_set_node_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.node_signature_1 = val.into_rust(); +} +/// Authentication of the announcement by the second public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_get_node_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature_2; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// Authentication of the announcement by the second public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_set_node_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.node_signature_2 = val.into_rust(); +} +/// Proof of funding UTXO ownership by the first public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature_1; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// Proof of funding UTXO ownership by the first public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.bitcoin_signature_1 = val.into_rust(); +} +/// Proof of funding UTXO ownership by the second public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature_2; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// Proof of funding UTXO ownership by the second public node +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.bitcoin_signature_2 = val.into_rust(); +} +/// The actual announcement +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_get_contents(this_ptr: &ChannelAnnouncement) -> crate::ln::msgs::UnsignedChannelAnnouncement { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents; + crate::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// The actual announcement +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_set_contents(this_ptr: &mut ChannelAnnouncement, mut val: crate::ln::msgs::UnsignedChannelAnnouncement) { + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_new(mut node_signature_1_arg: crate::c_types::Signature, mut node_signature_2_arg: crate::c_types::Signature, mut bitcoin_signature_1_arg: crate::c_types::Signature, mut bitcoin_signature_2_arg: crate::c_types::Signature, mut contents_arg: crate::ln::msgs::UnsignedChannelAnnouncement) -> ChannelAnnouncement { + ChannelAnnouncement { inner: Box::into_raw(Box::new(nativeChannelAnnouncement { + node_signature_1: node_signature_1_arg.into_rust(), + node_signature_2: node_signature_2_arg.into_rust(), + bitcoin_signature_1: bitcoin_signature_1_arg.into_rust(), + bitcoin_signature_2: bitcoin_signature_2_arg.into_rust(), + contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + })), is_owned: true } +} + +use lightning::ln::msgs::UnsignedChannelUpdate as nativeUnsignedChannelUpdateImport; +type nativeUnsignedChannelUpdate = nativeUnsignedChannelUpdateImport; + +/// The unsigned part of a channel_update +#[must_use] +#[repr(C)] +pub struct UnsignedChannelUpdate { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUnsignedChannelUpdate, + pub is_owned: bool, +} + +impl Drop for UnsignedChannelUpdate { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_free(this_ptr: UnsignedChannelUpdate) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UnsignedChannelUpdate_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelUpdate); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UnsignedChannelUpdate { + pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedChannelUpdate { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UnsignedChannelUpdate { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UnsignedChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelUpdate)).clone() })) as *mut c_void +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_chain_hash(this_ptr: &UnsignedChannelUpdate) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash; + (*inner_val).as_inner() +} +/// The genesis hash of the blockchain where the channel is to be opened +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_chain_hash(this_ptr: &mut UnsignedChannelUpdate, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap(); +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_short_channel_id(this_ptr: &UnsignedChannelUpdate) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id; + (*inner_val) +} +/// The short channel ID +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_short_channel_id(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) { + unsafe { &mut *this_ptr.inner }.short_channel_id = val; +} +/// A strictly monotonic announcement counter, with gaps allowed, specific to this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_timestamp(this_ptr: &UnsignedChannelUpdate) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.timestamp; + (*inner_val) +} +/// A strictly monotonic announcement counter, with gaps allowed, specific to this channel +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_timestamp(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) { + unsafe { &mut *this_ptr.inner }.timestamp = val; +} +/// Channel flags +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_flags(this_ptr: &UnsignedChannelUpdate) -> u8 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.flags; + (*inner_val) +} +/// Channel flags +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_flags(this_ptr: &mut UnsignedChannelUpdate, mut val: u8) { + unsafe { &mut *this_ptr.inner }.flags = val; +} +/// The number of blocks to subtract from incoming HTLC cltv_expiry values +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: &UnsignedChannelUpdate) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry_delta; + (*inner_val) +} +/// The number of blocks to subtract from incoming HTLC cltv_expiry values +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: &mut UnsignedChannelUpdate, mut val: u16) { + unsafe { &mut *this_ptr.inner }.cltv_expiry_delta = val; +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: &UnsignedChannelUpdate) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat; + (*inner_val) +} +/// The minimum HTLC size incoming to sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val; +} +/// The base HTLC fee charged by sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_fee_base_msat(this_ptr: &UnsignedChannelUpdate) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_base_msat; + (*inner_val) +} +/// The base HTLC fee charged by sender, in milli-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_fee_base_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) { + unsafe { &mut *this_ptr.inner }.fee_base_msat = val; +} +/// The amount to fee multiplier, in micro-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: &UnsignedChannelUpdate) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_proportional_millionths; + (*inner_val) +} +/// The amount to fee multiplier, in micro-satoshi +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) { + unsafe { &mut *this_ptr.inner }.fee_proportional_millionths = val; +} + +use lightning::ln::msgs::ChannelUpdate as nativeChannelUpdateImport; +type nativeChannelUpdate = nativeChannelUpdateImport; + +/// A channel_update message to be sent or received from a peer +#[must_use] +#[repr(C)] +pub struct ChannelUpdate { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelUpdate, + pub is_owned: bool, +} + +impl Drop for ChannelUpdate { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelUpdate_free(this_ptr: ChannelUpdate) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelUpdate_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelUpdate); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelUpdate { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelUpdate { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelUpdate { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelUpdate)).clone() })) as *mut c_void +} +/// A signature of the channel update +#[no_mangle] +pub extern "C" fn ChannelUpdate_get_signature(this_ptr: &ChannelUpdate) -> crate::c_types::Signature { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature; + crate::c_types::Signature::from_rust(&(*inner_val)) +} +/// A signature of the channel update +#[no_mangle] +pub extern "C" fn ChannelUpdate_set_signature(this_ptr: &mut ChannelUpdate, mut val: crate::c_types::Signature) { + unsafe { &mut *this_ptr.inner }.signature = val.into_rust(); +} +/// The actual channel update +#[no_mangle] +pub extern "C" fn ChannelUpdate_get_contents(this_ptr: &ChannelUpdate) -> crate::ln::msgs::UnsignedChannelUpdate { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents; + crate::ln::msgs::UnsignedChannelUpdate { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// The actual channel update +#[no_mangle] +pub extern "C" fn ChannelUpdate_set_contents(this_ptr: &mut ChannelUpdate, mut val: crate::ln::msgs::UnsignedChannelUpdate) { + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelUpdate_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::ln::msgs::UnsignedChannelUpdate) -> ChannelUpdate { + ChannelUpdate { inner: Box::into_raw(Box::new(nativeChannelUpdate { + signature: signature_arg.into_rust(), + contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + })), is_owned: true } +} +/// Used to put an error message in a LightningError +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum ErrorAction { + /// The peer took some action which made us think they were useless. Disconnect them. + DisconnectPeer { + msg: crate::ln::msgs::ErrorMessage, + }, + /// The peer did something harmless that we weren't able to process, just log and ignore + IgnoreError, + /// The peer did something incorrect. Tell them. + SendErrorMessage { + msg: crate::ln::msgs::ErrorMessage, + }, +} +use lightning::ln::msgs::ErrorAction as nativeErrorAction; +impl ErrorAction { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeErrorAction { + match self { + ErrorAction::DisconnectPeer {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + let mut local_msg_nonref = if msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg_nonref.take_ptr()) } }) }; + nativeErrorAction::DisconnectPeer { + msg: local_msg_nonref, + } + }, + ErrorAction::IgnoreError => nativeErrorAction::IgnoreError, + ErrorAction::SendErrorMessage {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + nativeErrorAction::SendErrorMessage { + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeErrorAction { + match self { + ErrorAction::DisconnectPeer {mut msg, } => { + let mut local_msg = if msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg.take_ptr()) } }) }; + nativeErrorAction::DisconnectPeer { + msg: local_msg, + } + }, + ErrorAction::IgnoreError => nativeErrorAction::IgnoreError, + ErrorAction::SendErrorMessage {mut msg, } => { + nativeErrorAction::SendErrorMessage { + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeErrorAction) -> Self { + match native { + nativeErrorAction::DisconnectPeer {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + let mut local_msg_nonref = crate::ln::msgs::ErrorMessage { inner: if msg_nonref.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((msg_nonref.unwrap()))) } }, is_owned: true }; + ErrorAction::DisconnectPeer { + msg: local_msg_nonref, + } + }, + nativeErrorAction::IgnoreError => ErrorAction::IgnoreError, + nativeErrorAction::SendErrorMessage {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + ErrorAction::SendErrorMessage { + msg: crate::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeErrorAction) -> Self { + match native { + nativeErrorAction::DisconnectPeer {mut msg, } => { + let mut local_msg = crate::ln::msgs::ErrorMessage { inner: if msg.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((msg.unwrap()))) } }, is_owned: true }; + ErrorAction::DisconnectPeer { + msg: local_msg, + } + }, + nativeErrorAction::IgnoreError => ErrorAction::IgnoreError, + nativeErrorAction::SendErrorMessage {mut msg, } => { + ErrorAction::SendErrorMessage { + msg: crate::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn ErrorAction_free(this_ptr: ErrorAction) { } + +use lightning::ln::msgs::LightningError as nativeLightningErrorImport; +type nativeLightningError = nativeLightningErrorImport; + +/// An Err type for failure to process messages. +#[must_use] +#[repr(C)] +pub struct LightningError { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeLightningError, + pub is_owned: bool, +} + +impl Drop for LightningError { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn LightningError_free(this_ptr: LightningError) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn LightningError_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeLightningError); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl LightningError { + pub(crate) fn take_ptr(mut self) -> *mut nativeLightningError { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// A human-readable message describing the error +#[no_mangle] +pub extern "C" fn LightningError_get_err(this_ptr: &LightningError) -> crate::c_types::Str { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.err; + (*inner_val).as_str().into() +} +/// A human-readable message describing the error +#[no_mangle] +pub extern "C" fn LightningError_set_err(this_ptr: &mut LightningError, mut val: crate::c_types::derived::CVec_u8Z) { + unsafe { &mut *this_ptr.inner }.err = String::from_utf8(val.into_rust()).unwrap(); +} +/// The action which should be taken against the offending peer. +#[no_mangle] +pub extern "C" fn LightningError_get_action(this_ptr: &LightningError) -> crate::ln::msgs::ErrorAction { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.action; + crate::ln::msgs::ErrorAction::from_native(&(*inner_val)) +} +/// The action which should be taken against the offending peer. +#[no_mangle] +pub extern "C" fn LightningError_set_action(this_ptr: &mut LightningError, mut val: crate::ln::msgs::ErrorAction) { + unsafe { &mut *this_ptr.inner }.action = val.into_native(); +} +#[must_use] +#[no_mangle] +pub extern "C" fn LightningError_new(mut err_arg: crate::c_types::derived::CVec_u8Z, mut action_arg: crate::ln::msgs::ErrorAction) -> LightningError { + LightningError { inner: Box::into_raw(Box::new(nativeLightningError { + err: String::from_utf8(err_arg.into_rust()).unwrap(), + action: action_arg.into_native(), + })), is_owned: true } +} + +use lightning::ln::msgs::CommitmentUpdate as nativeCommitmentUpdateImport; +type nativeCommitmentUpdate = nativeCommitmentUpdateImport; + +/// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment +/// transaction updates if they were pending. +#[must_use] +#[repr(C)] +pub struct CommitmentUpdate { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeCommitmentUpdate, + pub is_owned: bool, +} + +impl Drop for CommitmentUpdate { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn CommitmentUpdate_free(this_ptr: CommitmentUpdate) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn CommitmentUpdate_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentUpdate); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl CommitmentUpdate { + pub(crate) fn take_ptr(mut self) -> *mut nativeCommitmentUpdate { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for CommitmentUpdate { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn CommitmentUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentUpdate)).clone() })) as *mut c_void +} +/// update_add_htlc messages which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_update_add_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateAddHTLCZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + unsafe { &mut *this_ptr.inner }.update_add_htlcs = local_val; +} +/// update_fulfill_htlc messages which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFulfillHTLCZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + unsafe { &mut *this_ptr.inner }.update_fulfill_htlcs = local_val; +} +/// update_fail_htlc messages which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_update_fail_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailHTLCZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + unsafe { &mut *this_ptr.inner }.update_fail_htlcs = local_val; +} +/// update_fail_malformed_htlc messages which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + unsafe { &mut *this_ptr.inner }.update_fail_malformed_htlcs = local_val; +} +/// An update_fee message which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_get_update_fee(this_ptr: &CommitmentUpdate) -> crate::ln::msgs::UpdateFee { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.update_fee; + let mut local_inner_val = crate::ln::msgs::UpdateFee { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// An update_fee message which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_update_fee(this_ptr: &mut CommitmentUpdate, mut val: crate::ln::msgs::UpdateFee) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.update_fee = local_val; +} +/// Finally, the commitment_signed message which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_get_commitment_signed(this_ptr: &CommitmentUpdate) -> crate::ln::msgs::CommitmentSigned { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_signed; + crate::ln::msgs::CommitmentSigned { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// Finally, the commitment_signed message which should be sent +#[no_mangle] +pub extern "C" fn CommitmentUpdate_set_commitment_signed(this_ptr: &mut CommitmentUpdate, mut val: crate::ln::msgs::CommitmentSigned) { + unsafe { &mut *this_ptr.inner }.commitment_signed = *unsafe { Box::from_raw(val.take_ptr()) }; +} +#[must_use] +#[no_mangle] +pub extern "C" fn CommitmentUpdate_new(mut update_add_htlcs_arg: crate::c_types::derived::CVec_UpdateAddHTLCZ, mut update_fulfill_htlcs_arg: crate::c_types::derived::CVec_UpdateFulfillHTLCZ, mut update_fail_htlcs_arg: crate::c_types::derived::CVec_UpdateFailHTLCZ, mut update_fail_malformed_htlcs_arg: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ, mut update_fee_arg: crate::ln::msgs::UpdateFee, mut commitment_signed_arg: crate::ln::msgs::CommitmentSigned) -> CommitmentUpdate { + let mut local_update_add_htlcs_arg = Vec::new(); for mut item in update_add_htlcs_arg.into_rust().drain(..) { local_update_add_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_update_fulfill_htlcs_arg = Vec::new(); for mut item in update_fulfill_htlcs_arg.into_rust().drain(..) { local_update_fulfill_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_update_fail_htlcs_arg = Vec::new(); for mut item in update_fail_htlcs_arg.into_rust().drain(..) { local_update_fail_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_update_fail_malformed_htlcs_arg = Vec::new(); for mut item in update_fail_malformed_htlcs_arg.into_rust().drain(..) { local_update_fail_malformed_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_update_fee_arg = if update_fee_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_fee_arg.take_ptr()) } }) }; + CommitmentUpdate { inner: Box::into_raw(Box::new(nativeCommitmentUpdate { + update_add_htlcs: local_update_add_htlcs_arg, + update_fulfill_htlcs: local_update_fulfill_htlcs_arg, + update_fail_htlcs: local_update_fail_htlcs_arg, + update_fail_malformed_htlcs: local_update_fail_malformed_htlcs_arg, + update_fee: local_update_fee_arg, + commitment_signed: *unsafe { Box::from_raw(commitment_signed_arg.take_ptr()) }, + })), is_owned: true } +} +/// The information we received from a peer along the route of a payment we originated. This is +/// returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into +/// RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum HTLCFailChannelUpdate { + /// We received an error which included a full ChannelUpdate message. + ChannelUpdateMessage { + msg: crate::ln::msgs::ChannelUpdate, + }, + /// We received an error which indicated only that a channel has been closed + ChannelClosed { + short_channel_id: u64, + is_permanent: bool, + }, + /// We received an error which indicated only that a node has failed + NodeFailure { + node_id: crate::c_types::PublicKey, + is_permanent: bool, + }, +} +use lightning::ln::msgs::HTLCFailChannelUpdate as nativeHTLCFailChannelUpdate; +impl HTLCFailChannelUpdate { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeHTLCFailChannelUpdate { + match self { + HTLCFailChannelUpdate::ChannelUpdateMessage {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + nativeHTLCFailChannelUpdate::ChannelUpdateMessage { + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + HTLCFailChannelUpdate::ChannelClosed {ref short_channel_id, ref is_permanent, } => { + let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut is_permanent_nonref = (*is_permanent).clone(); + nativeHTLCFailChannelUpdate::ChannelClosed { + short_channel_id: short_channel_id_nonref, + is_permanent: is_permanent_nonref, + } + }, + HTLCFailChannelUpdate::NodeFailure {ref node_id, ref is_permanent, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut is_permanent_nonref = (*is_permanent).clone(); + nativeHTLCFailChannelUpdate::NodeFailure { + node_id: node_id_nonref.into_rust(), + is_permanent: is_permanent_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeHTLCFailChannelUpdate { + match self { + HTLCFailChannelUpdate::ChannelUpdateMessage {mut msg, } => { + nativeHTLCFailChannelUpdate::ChannelUpdateMessage { + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + HTLCFailChannelUpdate::ChannelClosed {mut short_channel_id, mut is_permanent, } => { + nativeHTLCFailChannelUpdate::ChannelClosed { + short_channel_id: short_channel_id, + is_permanent: is_permanent, + } + }, + HTLCFailChannelUpdate::NodeFailure {mut node_id, mut is_permanent, } => { + nativeHTLCFailChannelUpdate::NodeFailure { + node_id: node_id.into_rust(), + is_permanent: is_permanent, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeHTLCFailChannelUpdate) -> Self { + match native { + nativeHTLCFailChannelUpdate::ChannelUpdateMessage {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + HTLCFailChannelUpdate::ChannelUpdateMessage { + msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeHTLCFailChannelUpdate::ChannelClosed {ref short_channel_id, ref is_permanent, } => { + let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut is_permanent_nonref = (*is_permanent).clone(); + HTLCFailChannelUpdate::ChannelClosed { + short_channel_id: short_channel_id_nonref, + is_permanent: is_permanent_nonref, + } + }, + nativeHTLCFailChannelUpdate::NodeFailure {ref node_id, ref is_permanent, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut is_permanent_nonref = (*is_permanent).clone(); + HTLCFailChannelUpdate::NodeFailure { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + is_permanent: is_permanent_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeHTLCFailChannelUpdate) -> Self { + match native { + nativeHTLCFailChannelUpdate::ChannelUpdateMessage {mut msg, } => { + HTLCFailChannelUpdate::ChannelUpdateMessage { + msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeHTLCFailChannelUpdate::ChannelClosed {mut short_channel_id, mut is_permanent, } => { + HTLCFailChannelUpdate::ChannelClosed { + short_channel_id: short_channel_id, + is_permanent: is_permanent, + } + }, + nativeHTLCFailChannelUpdate::NodeFailure {mut node_id, mut is_permanent, } => { + HTLCFailChannelUpdate::NodeFailure { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + is_permanent: is_permanent, + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn HTLCFailChannelUpdate_free(this_ptr: HTLCFailChannelUpdate) { } +/// A trait to describe an object which can receive channel messages. +/// +/// Messages MAY be called in parallel when they originate from different their_node_ids, however +/// they MUST NOT be called in parallel when the two calls have the same their_node_id. +#[repr(C)] +pub struct ChannelMessageHandler { + pub this_arg: *mut c_void, + /// Handle an incoming open_channel message from the given peer. + pub handle_open_channel: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, their_features: crate::ln::features::InitFeatures, msg: &crate::ln::msgs::OpenChannel), + /// Handle an incoming accept_channel message from the given peer. + pub handle_accept_channel: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, their_features: crate::ln::features::InitFeatures, msg: &crate::ln::msgs::AcceptChannel), + /// Handle an incoming funding_created message from the given peer. + pub handle_funding_created: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingCreated), + /// Handle an incoming funding_signed message from the given peer. + pub handle_funding_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingSigned), + /// Handle an incoming funding_locked message from the given peer. + pub handle_funding_locked: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::FundingLocked), + /// Handle an incoming shutdown message from the given peer. + pub handle_shutdown: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::Shutdown), + /// Handle an incoming closing_signed message from the given peer. + pub handle_closing_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ClosingSigned), + /// Handle an incoming update_add_htlc message from the given peer. + pub handle_update_add_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateAddHTLC), + /// Handle an incoming update_fulfill_htlc message from the given peer. + pub handle_update_fulfill_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFulfillHTLC), + /// Handle an incoming update_fail_htlc message from the given peer. + pub handle_update_fail_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFailHTLC), + /// Handle an incoming update_fail_malformed_htlc message from the given peer. + pub handle_update_fail_malformed_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFailMalformedHTLC), + /// Handle an incoming commitment_signed message from the given peer. + pub handle_commitment_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::CommitmentSigned), + /// Handle an incoming revoke_and_ack message from the given peer. + pub handle_revoke_and_ack: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::RevokeAndACK), + /// Handle an incoming update_fee message from the given peer. + pub handle_update_fee: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::UpdateFee), + /// Handle an incoming announcement_signatures message from the given peer. + pub handle_announcement_signatures: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::AnnouncementSignatures), + /// Indicates a connection to the peer failed/an existing connection was lost. If no connection + /// is believed to be possible in the future (eg they're sending us messages we don't + /// understand or indicate they require unknown feature bits), no_connection_possible is set + /// and any outstanding channels should be failed. + pub peer_disconnected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, no_connection_possible: bool), + /// Handle a peer reconnecting, possibly generating channel_reestablish message(s). + pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::Init), + /// Handle an incoming channel_reestablish message from the given peer. + pub handle_channel_reestablish: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ChannelReestablish), + /// Handle an incoming error message from the given peer. + pub handle_error: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::ln::msgs::ErrorMessage), + pub MessageSendEventsProvider: crate::util::events::MessageSendEventsProvider, + pub free: Option, +} +impl lightning::util::events::MessageSendEventsProvider for ChannelMessageHandler { + fn get_and_clear_pending_msg_events(&self) -> Vec { + ::get_and_clear_pending_msg_events(&self.MessageSendEventsProvider) + } +} +unsafe impl Send for ChannelMessageHandler {} +unsafe impl Sync for ChannelMessageHandler {} + +use lightning::ln::msgs::ChannelMessageHandler as rustChannelMessageHandler; +impl rustChannelMessageHandler for ChannelMessageHandler { + fn handle_open_channel(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, their_features: lightning::ln::features::InitFeatures, msg: &lightning::ln::msgs::OpenChannel) { + (self.handle_open_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::features::InitFeatures { inner: Box::into_raw(Box::new(their_features)), is_owned: true }, &crate::ln::msgs::OpenChannel { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_accept_channel(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, their_features: lightning::ln::features::InitFeatures, msg: &lightning::ln::msgs::AcceptChannel) { + (self.handle_accept_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::features::InitFeatures { inner: Box::into_raw(Box::new(their_features)), is_owned: true }, &crate::ln::msgs::AcceptChannel { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_funding_created(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::FundingCreated) { + (self.handle_funding_created)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::FundingCreated { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_funding_signed(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::FundingSigned) { + (self.handle_funding_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::FundingSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_funding_locked(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::FundingLocked) { + (self.handle_funding_locked)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::FundingLocked { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_shutdown(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::Shutdown) { + (self.handle_shutdown)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::Shutdown { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_closing_signed(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::ClosingSigned) { + (self.handle_closing_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::ClosingSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_update_add_htlc(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::UpdateAddHTLC) { + (self.handle_update_add_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::UpdateAddHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_update_fulfill_htlc(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::UpdateFulfillHTLC) { + (self.handle_update_fulfill_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::UpdateFulfillHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_update_fail_htlc(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::UpdateFailHTLC) { + (self.handle_update_fail_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::UpdateFailHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_update_fail_malformed_htlc(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::UpdateFailMalformedHTLC) { + (self.handle_update_fail_malformed_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::UpdateFailMalformedHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_commitment_signed(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::CommitmentSigned) { + (self.handle_commitment_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::CommitmentSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_revoke_and_ack(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::RevokeAndACK) { + (self.handle_revoke_and_ack)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::RevokeAndACK { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_update_fee(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::UpdateFee) { + (self.handle_update_fee)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::UpdateFee { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_announcement_signatures(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::AnnouncementSignatures) { + (self.handle_announcement_signatures)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::AnnouncementSignatures { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn peer_disconnected(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, no_connection_possible: bool) { + (self.peer_disconnected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), no_connection_possible) + } + fn peer_connected(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::Init) { + (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::Init { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_channel_reestablish(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::ChannelReestablish) { + (self.handle_channel_reestablish)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::ChannelReestablish { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } + fn handle_error(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: &lightning::ln::msgs::ErrorMessage) { + (self.handle_error)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::ErrorMessage { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for ChannelMessageHandler { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn ChannelMessageHandler_free(this_ptr: ChannelMessageHandler) { } +impl Drop for ChannelMessageHandler { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// A trait to describe an object which can receive routing messages. +#[repr(C)] +pub struct RoutingMessageHandler { + pub this_arg: *mut c_void, + /// Handle an incoming node_announcement message, returning true if it should be forwarded on, + /// false or returning an Err otherwise. + #[must_use] + pub handle_node_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::ln::msgs::NodeAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ, + /// Handle a channel_announcement message, returning true if it should be forwarded on, false + /// or returning an Err otherwise. + #[must_use] + pub handle_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::ln::msgs::ChannelAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ, + /// Handle an incoming channel_update message, returning true if it should be forwarded on, + /// false or returning an Err otherwise. + #[must_use] + pub handle_channel_update: extern "C" fn (this_arg: *const c_void, msg: &crate::ln::msgs::ChannelUpdate) -> crate::c_types::derived::CResult_boolLightningErrorZ, + /// Handle some updates to the route graph that we learned due to an outbound failed payment. + pub handle_htlc_fail_channel_update: extern "C" fn (this_arg: *const c_void, update: &crate::ln::msgs::HTLCFailChannelUpdate), + /// Gets a subset of the channel announcements and updates required to dump our routing table + /// to a remote node, starting at the short_channel_id indicated by starting_point and + /// including the batch_amount entries immediately higher in numerical value than starting_point. + #[must_use] + pub get_next_channel_announcements: extern "C" fn (this_arg: *const c_void, starting_point: u64, batch_amount: u8) -> crate::c_types::derived::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ, + /// Gets a subset of the node announcements required to dump our routing table to a remote node, + /// starting at the node *after* the provided publickey and including batch_amount entries + /// immediately higher (as defined by ::cmp) than starting_point. + /// If None is provided for starting_point, we start at the first node. + #[must_use] + pub get_next_node_announcements: extern "C" fn (this_arg: *const c_void, starting_point: crate::c_types::PublicKey, batch_amount: u8) -> crate::c_types::derived::CVec_NodeAnnouncementZ, + /// Returns whether a full sync should be requested from a peer. + #[must_use] + pub should_request_full_sync: extern "C" fn (this_arg: *const c_void, node_id: crate::c_types::PublicKey) -> bool, + pub free: Option, +} +unsafe impl Send for RoutingMessageHandler {} +unsafe impl Sync for RoutingMessageHandler {} + +use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler; +impl rustRoutingMessageHandler for RoutingMessageHandler { + fn handle_node_announcement(&self, msg: &lightning::ln::msgs::NodeAnnouncement) -> Result { + let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::ln::msgs::NodeAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + local_ret + } + fn handle_channel_announcement(&self, msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result { + let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::ln::msgs::ChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + local_ret + } + fn handle_channel_update(&self, msg: &lightning::ln::msgs::ChannelUpdate) -> Result { + let mut ret = (self.handle_channel_update)(self.this_arg, &crate::ln::msgs::ChannelUpdate { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + local_ret + } + fn handle_htlc_fail_channel_update(&self, update: &lightning::ln::msgs::HTLCFailChannelUpdate) { + (self.handle_htlc_fail_channel_update)(self.this_arg, &crate::ln::msgs::HTLCFailChannelUpdate::from_native(&update)) + } + fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(lightning::ln::msgs::ChannelAnnouncement, Option, Option)> { + let mut ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item.to_rust(); let mut local_orig_ret_0_1 = if orig_ret_0_1.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_1.take_ptr()) } }) }; let mut local_orig_ret_0_2 = if orig_ret_0_2.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_2.take_ptr()) } }) }; let mut local_ret_0 = (*unsafe { Box::from_raw(orig_ret_0_0.take_ptr()) }, local_orig_ret_0_1, local_orig_ret_0_2); local_ret_0 }); }; + local_ret + } + fn get_next_node_announcements(&self, starting_point: Option<&bitcoin::secp256k1::key::PublicKey>, batch_amount: u8) -> Vec { + let mut local_starting_point = if starting_point.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(starting_point.unwrap())) } }; + let mut ret = (self.get_next_node_announcements)(self.this_arg, local_starting_point, batch_amount); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + local_ret + } + fn should_request_full_sync(&self, node_id: &bitcoin::secp256k1::key::PublicKey) -> bool { + let mut ret = (self.should_request_full_sync)(self.this_arg, crate::c_types::PublicKey::from_rust(&node_id)); + ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for RoutingMessageHandler { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn RoutingMessageHandler_free(this_ptr: RoutingMessageHandler) { } +impl Drop for RoutingMessageHandler { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +#[no_mangle] +pub extern "C" fn AcceptChannel_write(obj: *const AcceptChannel) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn AcceptChannel_read(ser: crate::c_types::u8slice) -> AcceptChannel { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + AcceptChannel { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + AcceptChannel { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_write(obj: *const AnnouncementSignatures) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_read(ser: crate::c_types::u8slice) -> AnnouncementSignatures { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + AnnouncementSignatures { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + AnnouncementSignatures { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn ChannelReestablish_write(obj: *const ChannelReestablish) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelReestablish_read(ser: crate::c_types::u8slice) -> ChannelReestablish { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelReestablish { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelReestablish { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn ClosingSigned_write(obj: *const ClosingSigned) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ClosingSigned_read(ser: crate::c_types::u8slice) -> ClosingSigned { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ClosingSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ClosingSigned { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn CommitmentSigned_write(obj: *const CommitmentSigned) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn CommitmentSigned_read(ser: crate::c_types::u8slice) -> CommitmentSigned { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + CommitmentSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + CommitmentSigned { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn FundingCreated_write(obj: *const FundingCreated) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn FundingCreated_read(ser: crate::c_types::u8slice) -> FundingCreated { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + FundingCreated { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + FundingCreated { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn FundingSigned_write(obj: *const FundingSigned) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn FundingSigned_read(ser: crate::c_types::u8slice) -> FundingSigned { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + FundingSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + FundingSigned { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn FundingLocked_write(obj: *const FundingLocked) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn FundingLocked_read(ser: crate::c_types::u8slice) -> FundingLocked { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + FundingLocked { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + FundingLocked { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn Init_write(obj: *const Init) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn Init_read(ser: crate::c_types::u8slice) -> Init { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + Init { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + Init { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn OpenChannel_write(obj: *const OpenChannel) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn OpenChannel_read(ser: crate::c_types::u8slice) -> OpenChannel { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + OpenChannel { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + OpenChannel { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn RevokeAndACK_write(obj: *const RevokeAndACK) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn RevokeAndACK_read(ser: crate::c_types::u8slice) -> RevokeAndACK { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + RevokeAndACK { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + RevokeAndACK { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn Shutdown_write(obj: *const Shutdown) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn Shutdown_read(ser: crate::c_types::u8slice) -> Shutdown { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + Shutdown { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + Shutdown { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_write(obj: *const UpdateFailHTLC) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_read(ser: crate::c_types::u8slice) -> UpdateFailHTLC { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UpdateFailHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UpdateFailHTLC { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_write(obj: *const UpdateFailMalformedHTLC) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_read(ser: crate::c_types::u8slice) -> UpdateFailMalformedHTLC { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UpdateFailMalformedHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UpdateFailMalformedHTLC { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UpdateFee_write(obj: *const UpdateFee) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UpdateFee_read(ser: crate::c_types::u8slice) -> UpdateFee { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UpdateFee { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UpdateFee { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_write(obj: *const UpdateFulfillHTLC) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_read(ser: crate::c_types::u8slice) -> UpdateFulfillHTLC { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UpdateFulfillHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UpdateFulfillHTLC { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_write(obj: *const UpdateAddHTLC) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_read(ser: crate::c_types::u8slice) -> UpdateAddHTLC { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UpdateAddHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UpdateAddHTLC { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn Ping_write(obj: *const Ping) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn Ping_read(ser: crate::c_types::u8slice) -> Ping { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + Ping { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + Ping { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn Pong_write(obj: *const Pong) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn Pong_read(ser: crate::c_types::u8slice) -> Pong { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + Pong { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + Pong { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_write(obj: *const UnsignedChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_read(ser: crate::c_types::u8slice) -> UnsignedChannelAnnouncement { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UnsignedChannelAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UnsignedChannelAnnouncement { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_write(obj: *const ChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_read(ser: crate::c_types::u8slice) -> ChannelAnnouncement { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelAnnouncement { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_write(obj: *const UnsignedChannelUpdate) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_read(ser: crate::c_types::u8slice) -> UnsignedChannelUpdate { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UnsignedChannelUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UnsignedChannelUpdate { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn ChannelUpdate_write(obj: *const ChannelUpdate) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelUpdate_read(ser: crate::c_types::u8slice) -> ChannelUpdate { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelUpdate { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn ErrorMessage_write(obj: *const ErrorMessage) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ErrorMessage_read(ser: crate::c_types::u8slice) -> ErrorMessage { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ErrorMessage { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ErrorMessage { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_write(obj: *const UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_read(ser: crate::c_types::u8slice) -> UnsignedNodeAnnouncement { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + UnsignedNodeAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + UnsignedNodeAnnouncement { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn NodeAnnouncement_write(obj: *const NodeAnnouncement) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn NodeAnnouncement_read(ser: crate::c_types::u8slice) -> NodeAnnouncement { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + NodeAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + NodeAnnouncement { inner: std::ptr::null_mut(), is_owned: true } + } +} diff --git a/lightning-c-bindings/src/ln/peer_handler.rs b/lightning-c-bindings/src/ln/peer_handler.rs new file mode 100644 index 000000000..a763db63e --- /dev/null +++ b/lightning-c-bindings/src/ln/peer_handler.rs @@ -0,0 +1,406 @@ +//! Top level peer message handling and socket handling logic lives here. +//! +//! Instead of actually servicing sockets ourselves we require that you implement the +//! SocketDescriptor interface and use that to receive actions which you should perform on the +//! socket, and call into PeerManager with bytes read from the socket. The PeerManager will then +//! call into the provided message handlers (probably a ChannelManager and NetGraphmsgHandler) with messages +//! they should handle, and encoding/sending response messages. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::ln::peer_handler::MessageHandler as nativeMessageHandlerImport; +type nativeMessageHandler = nativeMessageHandlerImport; + +/// Provides references to trait impls which handle different types of messages. +#[must_use] +#[repr(C)] +pub struct MessageHandler { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeMessageHandler, + pub is_owned: bool, +} + +impl Drop for MessageHandler { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn MessageHandler_free(this_ptr: MessageHandler) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn MessageHandler_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMessageHandler); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl MessageHandler { + pub(crate) fn take_ptr(mut self) -> *mut nativeMessageHandler { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// A message handler which handles messages specific to channels. Usually this is just a +/// ChannelManager object. +#[no_mangle] +pub extern "C" fn MessageHandler_get_chan_handler(this_ptr: &MessageHandler) -> *const crate::ln::msgs::ChannelMessageHandler { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chan_handler; + &(*inner_val) +} +/// A message handler which handles messages specific to channels. Usually this is just a +/// ChannelManager object. +#[no_mangle] +pub extern "C" fn MessageHandler_set_chan_handler(this_ptr: &mut MessageHandler, mut val: crate::ln::msgs::ChannelMessageHandler) { + unsafe { &mut *this_ptr.inner }.chan_handler = val; +} +/// A message handler which handles messages updating our knowledge of the network channel +/// graph. Usually this is just a NetGraphMsgHandlerMonitor object. +#[no_mangle] +pub extern "C" fn MessageHandler_get_route_handler(this_ptr: &MessageHandler) -> *const crate::ln::msgs::RoutingMessageHandler { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.route_handler; + &(*inner_val) +} +/// A message handler which handles messages updating our knowledge of the network channel +/// graph. Usually this is just a NetGraphMsgHandlerMonitor object. +#[no_mangle] +pub extern "C" fn MessageHandler_set_route_handler(this_ptr: &mut MessageHandler, mut val: crate::ln::msgs::RoutingMessageHandler) { + unsafe { &mut *this_ptr.inner }.route_handler = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn MessageHandler_new(mut chan_handler_arg: crate::ln::msgs::ChannelMessageHandler, mut route_handler_arg: crate::ln::msgs::RoutingMessageHandler) -> MessageHandler { + MessageHandler { inner: Box::into_raw(Box::new(nativeMessageHandler { + chan_handler: chan_handler_arg, + route_handler: route_handler_arg, + })), is_owned: true } +} +/// Provides an object which can be used to send data to and which uniquely identifies a connection +/// to a remote host. You will need to be able to generate multiple of these which meet Eq and +/// implement Hash to meet the PeerManager API. +/// +/// For efficiency, Clone should be relatively cheap for this type. +/// +/// You probably want to just extend an int and put a file descriptor in a struct and implement +/// send_data. Note that if you are using a higher-level net library that may call close() itself, +/// be careful to ensure you don't have races whereby you might register a new connection with an +/// fd which is the same as a previous one which has yet to be removed via +/// PeerManager::socket_disconnected(). +#[repr(C)] +pub struct SocketDescriptor { + pub this_arg: *mut c_void, + /// Attempts to send some data from the given slice to the peer. + /// + /// Returns the amount of data which was sent, possibly 0 if the socket has since disconnected. + /// Note that in the disconnected case, socket_disconnected must still fire and further write + /// attempts may occur until that time. + /// + /// If the returned size is smaller than data.len(), a write_available event must + /// trigger the next time more data can be written. Additionally, until the a send_data event + /// completes fully, no further read_events should trigger on the same peer! + /// + /// If a read_event on this descriptor had previously returned true (indicating that read + /// events should be paused to prevent DoS in the send buffer), resume_read may be set + /// indicating that read events on this descriptor should resume. A resume_read of false does + /// *not* imply that further read events should be paused. + #[must_use] + pub send_data: extern "C" fn (this_arg: *mut c_void, data: crate::c_types::u8slice, resume_read: bool) -> usize, + /// Disconnect the socket pointed to by this SocketDescriptor. Once this function returns, no + /// more calls to write_buffer_space_avail, read_event or socket_disconnected may be made with + /// this descriptor. No socket_disconnected call should be generated as a result of this call, + /// though races may occur whereby disconnect_socket is called after a call to + /// socket_disconnected but prior to socket_disconnected returning. + pub disconnect_socket: extern "C" fn (this_arg: *mut c_void), + pub eq: extern "C" fn (this_arg: *const c_void, other_arg: *const c_void) -> bool, + pub hash: extern "C" fn (this_arg: *const c_void) -> u64, + pub clone: Option *mut c_void>, + pub free: Option, +} +impl std::cmp::Eq for SocketDescriptor {} +impl std::cmp::PartialEq for SocketDescriptor { + fn eq(&self, o: &Self) -> bool { (self.eq)(self.this_arg, o.this_arg) } +} +impl std::hash::Hash for SocketDescriptor { + fn hash(&self, hasher: &mut H) { hasher.write_u64((self.hash)(self.this_arg)) } +} +impl Clone for SocketDescriptor { + fn clone(&self) -> Self { + Self { + this_arg: if let Some(f) = self.clone { (f)(self.this_arg) } else { self.this_arg }, + send_data: self.send_data.clone(), + disconnect_socket: self.disconnect_socket.clone(), + eq: self.eq.clone(), + hash: self.hash.clone(), + clone: self.clone.clone(), + free: self.free.clone(), + } + } +} + +use lightning::ln::peer_handler::SocketDescriptor as rustSocketDescriptor; +impl rustSocketDescriptor for SocketDescriptor { + fn send_data(&mut self, data: &[u8], resume_read: bool) -> usize { + let mut local_data = crate::c_types::u8slice::from_slice(data); + let mut ret = (self.send_data)(self.this_arg, local_data, resume_read); + ret + } + fn disconnect_socket(&mut self) { + (self.disconnect_socket)(self.this_arg) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for SocketDescriptor { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn SocketDescriptor_free(this_ptr: SocketDescriptor) { } +impl Drop for SocketDescriptor { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} + +use lightning::ln::peer_handler::PeerHandleError as nativePeerHandleErrorImport; +type nativePeerHandleError = nativePeerHandleErrorImport; + +/// Error for PeerManager errors. If you get one of these, you must disconnect the socket and +/// generate no further read_event/write_buffer_space_avail calls for the descriptor, only +/// triggering a single socket_disconnected call (unless it was provided in response to a +/// new_*_connection event, in which case no such socket_disconnected() must be called and the +/// socket silently disconencted). +#[must_use] +#[repr(C)] +pub struct PeerHandleError { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePeerHandleError, + pub is_owned: bool, +} + +impl Drop for PeerHandleError { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn PeerHandleError_free(this_ptr: PeerHandleError) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn PeerHandleError_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePeerHandleError); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl PeerHandleError { + pub(crate) fn take_ptr(mut self) -> *mut nativePeerHandleError { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Used to indicate that we probably can't make any future connections to this peer, implying +/// we should go ahead and force-close any channels we have with it. +#[no_mangle] +pub extern "C" fn PeerHandleError_get_no_connection_possible(this_ptr: &PeerHandleError) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.no_connection_possible; + (*inner_val) +} +/// Used to indicate that we probably can't make any future connections to this peer, implying +/// we should go ahead and force-close any channels we have with it. +#[no_mangle] +pub extern "C" fn PeerHandleError_set_no_connection_possible(this_ptr: &mut PeerHandleError, mut val: bool) { + unsafe { &mut *this_ptr.inner }.no_connection_possible = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn PeerHandleError_new(mut no_connection_possible_arg: bool) -> PeerHandleError { + PeerHandleError { inner: Box::into_raw(Box::new(nativePeerHandleError { + no_connection_possible: no_connection_possible_arg, + })), is_owned: true } +} + +use lightning::ln::peer_handler::PeerManager as nativePeerManagerImport; +type nativePeerManager = nativePeerManagerImport; + +/// A PeerManager manages a set of peers, described by their SocketDescriptor and marshalls socket +/// events into messages which it passes on to its MessageHandlers. +/// +/// Rather than using a plain PeerManager, it is preferable to use either a SimpleArcPeerManager +/// a SimpleRefPeerManager, for conciseness. See their documentation for more details, but +/// essentially you should default to using a SimpleRefPeerManager, and use a +/// SimpleArcPeerManager when you require a PeerManager with a static lifetime, such as when +/// you're using lightning-net-tokio. +#[must_use] +#[repr(C)] +pub struct PeerManager { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativePeerManager, + pub is_owned: bool, +} + +impl Drop for PeerManager { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn PeerManager_free(this_ptr: PeerManager) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn PeerManager_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativePeerManager); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl PeerManager { + pub(crate) fn take_ptr(mut self) -> *mut nativePeerManager { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Constructs a new PeerManager with the given message handlers and node_id secret key +/// ephemeral_random_data is used to derive per-connection ephemeral keys and must be +/// cryptographically secure random bytes. +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_new(mut message_handler: crate::ln::peer_handler::MessageHandler, mut our_node_secret: crate::c_types::SecretKey, ephemeral_random_data: *const [u8; 32], mut logger: crate::util::logger::Logger) -> PeerManager { + let mut ret = lightning::ln::peer_handler::PeerManager::new(*unsafe { Box::from_raw(message_handler.take_ptr()) }, our_node_secret.into_rust(), unsafe { &*ephemeral_random_data}, logger); + PeerManager { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Get the list of node ids for peers which have completed the initial handshake. +/// +/// For outbound connections, this will be the same as the their_node_id parameter passed in to +/// new_outbound_connection, however entries will only appear once the initial handshake has +/// completed and we are sure the remote peer has the private key for the given node_id. +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_get_peer_node_ids(this_arg: &PeerManager) -> crate::c_types::derived::CVec_PublicKeyZ { + let mut ret = unsafe { &*this_arg.inner }.get_peer_node_ids(); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::c_types::PublicKey::from_rust(&item) }); }; + local_ret.into() +} + +/// Indicates a new outbound connection has been established to a node with the given node_id. +/// Note that if an Err is returned here you MUST NOT call socket_disconnected for the new +/// descriptor but must disconnect the connection immediately. +/// +/// Returns a small number of bytes to send to the remote node (currently always 50). +/// +/// Panics if descriptor is duplicative with some other descriptor which has not yet had a +/// socket_disconnected(). +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_new_outbound_connection(this_arg: &PeerManager, mut their_node_id: crate::c_types::PublicKey, mut descriptor: crate::ln::peer_handler::SocketDescriptor) -> crate::c_types::derived::CResult_CVec_u8ZPeerHandleErrorZ { + let mut ret = unsafe { &*this_arg.inner }.new_outbound_connection(their_node_id.into_rust(), descriptor); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_ret_0 = Vec::new(); for item in o.drain(..) { local_ret_0.push( { item }); }; local_ret_0.into() }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::peer_handler::PeerHandleError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Indicates a new inbound connection has been established. +/// +/// May refuse the connection by returning an Err, but will never write bytes to the remote end +/// (outbound connector always speaks first). Note that if an Err is returned here you MUST NOT +/// call socket_disconnected for the new descriptor but must disconnect the connection +/// immediately. +/// +/// Panics if descriptor is duplicative with some other descriptor which has not yet had +/// socket_disconnected called. +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_new_inbound_connection(this_arg: &PeerManager, mut descriptor: crate::ln::peer_handler::SocketDescriptor) -> crate::c_types::derived::CResult_NonePeerHandleErrorZ { + let mut ret = unsafe { &*this_arg.inner }.new_inbound_connection(descriptor); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::peer_handler::PeerHandleError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Indicates that there is room to write data to the given socket descriptor. +/// +/// May return an Err to indicate that the connection should be closed. +/// +/// Will most likely call send_data on the descriptor passed in (or the descriptor handed into +/// new_*\\_connection) before returning. Thus, be very careful with reentrancy issues! The +/// invariants around calling write_buffer_space_avail in case a write did not fully complete +/// must still hold - be ready to call write_buffer_space_avail again if a write call generated +/// here isn't sufficient! Panics if the descriptor was not previously registered in a +/// new_\\*_connection event. +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_write_buffer_space_avail(this_arg: &PeerManager, descriptor: &mut crate::ln::peer_handler::SocketDescriptor) -> crate::c_types::derived::CResult_NonePeerHandleErrorZ { + let mut ret = unsafe { &*this_arg.inner }.write_buffer_space_avail(descriptor); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::peer_handler::PeerHandleError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Indicates that data was read from the given socket descriptor. +/// +/// May return an Err to indicate that the connection should be closed. +/// +/// Will *not* call back into send_data on any descriptors to avoid reentrancy complexity. +/// Thus, however, you almost certainly want to call process_events() after any read_event to +/// generate send_data calls to handle responses. +/// +/// If Ok(true) is returned, further read_events should not be triggered until a send_data call +/// on this file descriptor has resume_read set (preventing DoS issues in the send buffer). +/// +/// Panics if the descriptor was not previously registered in a new_*_connection event. +#[must_use] +#[no_mangle] +pub extern "C" fn PeerManager_read_event(this_arg: &PeerManager, peer_descriptor: &mut crate::ln::peer_handler::SocketDescriptor, mut data: crate::c_types::u8slice) -> crate::c_types::derived::CResult_boolPeerHandleErrorZ { + let mut ret = unsafe { &*this_arg.inner }.read_event(peer_descriptor, data.to_slice()); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::peer_handler::PeerHandleError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + +/// Checks for any events generated by our handlers and processes them. Includes sending most +/// response messages as well as messages generated by calls to handler functions directly (eg +/// functions like ChannelManager::process_pending_htlc_forward or send_payment). +#[no_mangle] +pub extern "C" fn PeerManager_process_events(this_arg: &PeerManager) { + unsafe { &*this_arg.inner }.process_events() +} + +/// Indicates that the given socket descriptor's connection is now closed. +/// +/// This must only be called if the socket has been disconnected by the peer or your own +/// decision to disconnect it and must NOT be called in any case where other parts of this +/// library (eg PeerHandleError, explicit disconnect_socket calls) instruct you to disconnect +/// the peer. +/// +/// Panics if the descriptor was not previously registered in a successful new_*_connection event. +#[no_mangle] +pub extern "C" fn PeerManager_socket_disconnected(this_arg: &PeerManager, descriptor: &crate::ln::peer_handler::SocketDescriptor) { + unsafe { &*this_arg.inner }.socket_disconnected(descriptor) +} + +/// This function should be called roughly once every 30 seconds. +/// It will send pings to each peer and disconnect those which did not respond to the last round of pings. +/// Will most likely call send_data on all of the registered descriptors, thus, be very careful with reentrancy issues! +#[no_mangle] +pub extern "C" fn PeerManager_timer_tick_occured(this_arg: &PeerManager) { + unsafe { &*this_arg.inner }.timer_tick_occured() +} + diff --git a/lightning-c-bindings/src/routing/mod.rs b/lightning-c-bindings/src/routing/mod.rs new file mode 100644 index 000000000..4311ff353 --- /dev/null +++ b/lightning-c-bindings/src/routing/mod.rs @@ -0,0 +1,8 @@ +//! Structs and impls for receiving messages about the network and storing the topology live here. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +pub mod router; +pub mod network_graph; diff --git a/lightning-c-bindings/src/routing/network_graph.rs b/lightning-c-bindings/src/routing/network_graph.rs new file mode 100644 index 000000000..89f20fd48 --- /dev/null +++ b/lightning-c-bindings/src/routing/network_graph.rs @@ -0,0 +1,795 @@ +//! The top-level network map tracking logic lives here. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::routing::network_graph::NetworkGraph as nativeNetworkGraphImport; +type nativeNetworkGraph = nativeNetworkGraphImport; + +/// Represents the network as nodes and channels between them +#[must_use] +#[repr(C)] +pub struct NetworkGraph { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNetworkGraph, + pub is_owned: bool, +} + +impl Drop for NetworkGraph { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NetworkGraph_free(this_ptr: NetworkGraph) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NetworkGraph_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNetworkGraph); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NetworkGraph { + pub(crate) fn take_ptr(mut self) -> *mut nativeNetworkGraph { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::routing::network_graph::LockedNetworkGraph as nativeLockedNetworkGraphImport; +type nativeLockedNetworkGraph = nativeLockedNetworkGraphImport<'static>; + +/// A simple newtype for RwLockReadGuard<'a, NetworkGraph>. +/// This exists only to make accessing a RwLock possible from +/// the C bindings, as it can be done directly in Rust code. +#[must_use] +#[repr(C)] +pub struct LockedNetworkGraph { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeLockedNetworkGraph, + pub is_owned: bool, +} + +impl Drop for LockedNetworkGraph { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn LockedNetworkGraph_free(this_ptr: LockedNetworkGraph) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn LockedNetworkGraph_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeLockedNetworkGraph); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl LockedNetworkGraph { + pub(crate) fn take_ptr(mut self) -> *mut nativeLockedNetworkGraph { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} + +use lightning::routing::network_graph::NetGraphMsgHandler as nativeNetGraphMsgHandlerImport; +type nativeNetGraphMsgHandler = nativeNetGraphMsgHandlerImport; + +/// Receives and validates network updates from peers, +/// stores authentic and relevant data as a network graph. +/// This network graph is then used for routing payments. +/// Provides interface to help with initial routing sync by +/// serving historical announcements. +#[must_use] +#[repr(C)] +pub struct NetGraphMsgHandler { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNetGraphMsgHandler, + pub is_owned: bool, +} + +impl Drop for NetGraphMsgHandler { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NetGraphMsgHandler_free(this_ptr: NetGraphMsgHandler) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NetGraphMsgHandler_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNetGraphMsgHandler); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NetGraphMsgHandler { + pub(crate) fn take_ptr(mut self) -> *mut nativeNetGraphMsgHandler { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Creates a new tracker of the actual state of the network of channels and nodes, +/// assuming a fresh network graph. +/// Chain monitor is used to make sure announced channels exist on-chain, +/// channel data is correct, and that the announcement is signed with +/// channel owners' keys. +#[must_use] +#[no_mangle] +pub extern "C" fn NetGraphMsgHandler_new(mut chain_monitor: crate::chain::chaininterface::ChainWatchInterface, mut logger: crate::util::logger::Logger) -> NetGraphMsgHandler { + let mut ret = lightning::routing::network_graph::NetGraphMsgHandler::new(chain_monitor, logger); + NetGraphMsgHandler { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Creates a new tracker of the actual state of the network of channels and nodes, +/// assuming an existing Network Graph. +#[must_use] +#[no_mangle] +pub extern "C" fn NetGraphMsgHandler_from_net_graph(mut chain_monitor: crate::chain::chaininterface::ChainWatchInterface, mut logger: crate::util::logger::Logger, mut network_graph: crate::routing::network_graph::NetworkGraph) -> NetGraphMsgHandler { + let mut ret = lightning::routing::network_graph::NetGraphMsgHandler::from_net_graph(chain_monitor, logger, *unsafe { Box::from_raw(network_graph.take_ptr()) }); + NetGraphMsgHandler { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Take a read lock on the network_graph and return it in the C-bindings +/// newtype helper. This is likely only useful when called via the C +/// bindings as you can call `self.network_graph.read().unwrap()` in Rust +/// yourself. +#[must_use] +#[no_mangle] +pub extern "C" fn NetGraphMsgHandler_read_locked_graph(this_arg: &NetGraphMsgHandler) -> crate::routing::network_graph::LockedNetworkGraph { + let mut ret = unsafe { &*this_arg.inner }.read_locked_graph(); + crate::routing::network_graph::LockedNetworkGraph { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Get a reference to the NetworkGraph which this read-lock contains. +#[must_use] +#[no_mangle] +pub extern "C" fn LockedNetworkGraph_graph(this_arg: &LockedNetworkGraph) -> crate::routing::network_graph::NetworkGraph { + let mut ret = unsafe { &*this_arg.inner }.graph(); + crate::routing::network_graph::NetworkGraph { inner: unsafe { ( (&(*ret) as *const _) as *mut _) }, is_owned: false } +} + +#[no_mangle] +pub extern "C" fn NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: *const NetGraphMsgHandler) -> crate::ln::msgs::RoutingMessageHandler { + crate::ln::msgs::RoutingMessageHandler { + this_arg: unsafe { (*this_arg).inner as *mut c_void }, + free: None, + handle_node_announcement: NetGraphMsgHandler_RoutingMessageHandler_handle_node_announcement, + handle_channel_announcement: NetGraphMsgHandler_RoutingMessageHandler_handle_channel_announcement, + handle_channel_update: NetGraphMsgHandler_RoutingMessageHandler_handle_channel_update, + handle_htlc_fail_channel_update: NetGraphMsgHandler_RoutingMessageHandler_handle_htlc_fail_channel_update, + get_next_channel_announcements: NetGraphMsgHandler_RoutingMessageHandler_get_next_channel_announcements, + get_next_node_announcements: NetGraphMsgHandler_RoutingMessageHandler_get_next_node_announcements, + should_request_full_sync: NetGraphMsgHandler_RoutingMessageHandler_should_request_full_sync, + } +} +use lightning::ln::msgs::RoutingMessageHandler as RoutingMessageHandlerTraitImport; +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_handle_node_announcement(this_arg: *const c_void, msg: &crate::ln::msgs::NodeAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.handle_node_announcement(unsafe { &*msg.inner }); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::LightningError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_handle_channel_announcement(this_arg: *const c_void, msg: &crate::ln::msgs::ChannelAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.handle_channel_announcement(unsafe { &*msg.inner }); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::LightningError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_handle_htlc_fail_channel_update(this_arg: *const c_void, update: &crate::ln::msgs::HTLCFailChannelUpdate) { + unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.handle_htlc_fail_channel_update(&update.to_native()) +} +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_handle_channel_update(this_arg: *const c_void, msg: &crate::ln::msgs::ChannelUpdate) -> crate::c_types::derived::CResult_boolLightningErrorZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.handle_channel_update(unsafe { &*msg.inner }); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::LightningError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_get_next_channel_announcements(this_arg: *const c_void, mut starting_point: u64, mut batch_amount: u8) -> crate::c_types::derived::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ { + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.get_next_channel_announcements(starting_point, batch_amount); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item; let mut local_orig_ret_0_1 = crate::ln::msgs::ChannelUpdate { inner: if orig_ret_0_1.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((orig_ret_0_1.unwrap()))) } }, is_owned: true }; let mut local_orig_ret_0_2 = crate::ln::msgs::ChannelUpdate { inner: if orig_ret_0_2.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((orig_ret_0_2.unwrap()))) } }, is_owned: true }; let mut local_ret_0 = (crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(orig_ret_0_0)), is_owned: true }, local_orig_ret_0_1, local_orig_ret_0_2).into(); local_ret_0 }); }; + local_ret.into() +} +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_get_next_node_announcements(this_arg: *const c_void, mut starting_point: crate::c_types::PublicKey, mut batch_amount: u8) -> crate::c_types::derived::CVec_NodeAnnouncementZ { + let mut local_starting_point_base = if starting_point.is_null() { None } else { Some( { starting_point.into_rust() }) }; let mut local_starting_point = local_starting_point_base.as_ref(); + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.get_next_node_announcements(local_starting_point, batch_amount); + let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(item)), is_owned: true } }); }; + local_ret.into() +} +#[must_use] +extern "C" fn NetGraphMsgHandler_RoutingMessageHandler_should_request_full_sync(this_arg: *const c_void, _node_id: crate::c_types::PublicKey) -> bool { + let mut ret = unsafe { &mut *(this_arg as *mut nativeNetGraphMsgHandler) }.should_request_full_sync(&_node_id.into_rust()); + ret +} + + +use lightning::routing::network_graph::DirectionalChannelInfo as nativeDirectionalChannelInfoImport; +type nativeDirectionalChannelInfo = nativeDirectionalChannelInfoImport; + +/// Details about one direction of a channel. Received +/// within a channel update. +#[must_use] +#[repr(C)] +pub struct DirectionalChannelInfo { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeDirectionalChannelInfo, + pub is_owned: bool, +} + +impl Drop for DirectionalChannelInfo { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_free(this_ptr: DirectionalChannelInfo) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn DirectionalChannelInfo_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDirectionalChannelInfo); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl DirectionalChannelInfo { + pub(crate) fn take_ptr(mut self) -> *mut nativeDirectionalChannelInfo { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// When the last update to the channel direction was issued. +/// Value is opaque, as set in the announcement. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_get_last_update(this_ptr: &DirectionalChannelInfo) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.last_update; + (*inner_val) +} +/// When the last update to the channel direction was issued. +/// Value is opaque, as set in the announcement. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_set_last_update(this_ptr: &mut DirectionalChannelInfo, mut val: u32) { + unsafe { &mut *this_ptr.inner }.last_update = val; +} +/// Whether the channel can be currently used for payments (in this one direction). +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_get_enabled(this_ptr: &DirectionalChannelInfo) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.enabled; + (*inner_val) +} +/// Whether the channel can be currently used for payments (in this one direction). +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_set_enabled(this_ptr: &mut DirectionalChannelInfo, mut val: bool) { + unsafe { &mut *this_ptr.inner }.enabled = val; +} +/// The difference in CLTV values that you must have when routing through this channel. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr: &DirectionalChannelInfo) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry_delta; + (*inner_val) +} +/// The difference in CLTV values that you must have when routing through this channel. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr: &mut DirectionalChannelInfo, mut val: u16) { + unsafe { &mut *this_ptr.inner }.cltv_expiry_delta = val; +} +/// The minimum value, which must be relayed to the next hop via the channel +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr: &DirectionalChannelInfo) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat; + (*inner_val) +} +/// The minimum value, which must be relayed to the next hop via the channel +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr: &mut DirectionalChannelInfo, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val; +} +/// Most recent update for the channel received from the network +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_get_last_update_message(this_ptr: &DirectionalChannelInfo) -> crate::ln::msgs::ChannelUpdate { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.last_update_message; + let mut local_inner_val = crate::ln::msgs::ChannelUpdate { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// Most recent update for the channel received from the network +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_set_last_update_message(this_ptr: &mut DirectionalChannelInfo, mut val: crate::ln::msgs::ChannelUpdate) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.last_update_message = local_val; +} +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_write(obj: *const DirectionalChannelInfo) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn DirectionalChannelInfo_read(ser: crate::c_types::u8slice) -> DirectionalChannelInfo { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + DirectionalChannelInfo { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + DirectionalChannelInfo { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::routing::network_graph::ChannelInfo as nativeChannelInfoImport; +type nativeChannelInfo = nativeChannelInfoImport; + +/// Details about a channel (both directions). +/// Received within a channel announcement. +#[must_use] +#[repr(C)] +pub struct ChannelInfo { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelInfo, + pub is_owned: bool, +} + +impl Drop for ChannelInfo { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelInfo_free(this_ptr: ChannelInfo) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelInfo_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelInfo); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelInfo { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelInfo { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// Source node of the first direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_get_node_one(this_ptr: &ChannelInfo) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_one; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Source node of the first direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_set_node_one(this_ptr: &mut ChannelInfo, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.node_one = val.into_rust(); +} +/// Details about the first direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_get_one_to_two(this_ptr: &ChannelInfo) -> crate::routing::network_graph::DirectionalChannelInfo { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.one_to_two; + let mut local_inner_val = crate::routing::network_graph::DirectionalChannelInfo { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// Details about the first direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_set_one_to_two(this_ptr: &mut ChannelInfo, mut val: crate::routing::network_graph::DirectionalChannelInfo) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.one_to_two = local_val; +} +/// Source node of the second direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_get_node_two(this_ptr: &ChannelInfo) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_two; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// Source node of the second direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_set_node_two(this_ptr: &mut ChannelInfo, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.node_two = val.into_rust(); +} +/// Details about the second direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_get_two_to_one(this_ptr: &ChannelInfo) -> crate::routing::network_graph::DirectionalChannelInfo { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.two_to_one; + let mut local_inner_val = crate::routing::network_graph::DirectionalChannelInfo { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// Details about the second direction of a channel +#[no_mangle] +pub extern "C" fn ChannelInfo_set_two_to_one(this_ptr: &mut ChannelInfo, mut val: crate::routing::network_graph::DirectionalChannelInfo) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.two_to_one = local_val; +} +/// An initial announcement of the channel +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn ChannelInfo_get_announcement_message(this_ptr: &ChannelInfo) -> crate::ln::msgs::ChannelAnnouncement { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.announcement_message; + let mut local_inner_val = crate::ln::msgs::ChannelAnnouncement { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// An initial announcement of the channel +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn ChannelInfo_set_announcement_message(this_ptr: &mut ChannelInfo, mut val: crate::ln::msgs::ChannelAnnouncement) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.announcement_message = local_val; +} +#[no_mangle] +pub extern "C" fn ChannelInfo_write(obj: *const ChannelInfo) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelInfo_read(ser: crate::c_types::u8slice) -> ChannelInfo { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelInfo { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelInfo { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::routing::network_graph::RoutingFees as nativeRoutingFeesImport; +type nativeRoutingFees = nativeRoutingFeesImport; + +/// Fees for routing via a given channel or a node +#[must_use] +#[repr(C)] +pub struct RoutingFees { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeRoutingFees, + pub is_owned: bool, +} + +impl Drop for RoutingFees { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn RoutingFees_free(this_ptr: RoutingFees) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn RoutingFees_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRoutingFees); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl RoutingFees { + pub(crate) fn take_ptr(mut self) -> *mut nativeRoutingFees { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for RoutingFees { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn RoutingFees_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRoutingFees)).clone() })) as *mut c_void +} +/// Flat routing fee in satoshis +#[no_mangle] +pub extern "C" fn RoutingFees_get_base_msat(this_ptr: &RoutingFees) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.base_msat; + (*inner_val) +} +/// Flat routing fee in satoshis +#[no_mangle] +pub extern "C" fn RoutingFees_set_base_msat(this_ptr: &mut RoutingFees, mut val: u32) { + unsafe { &mut *this_ptr.inner }.base_msat = val; +} +/// Liquidity-based routing fee in millionths of a routed amount. +/// In other words, 10000 is 1%. +#[no_mangle] +pub extern "C" fn RoutingFees_get_proportional_millionths(this_ptr: &RoutingFees) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.proportional_millionths; + (*inner_val) +} +/// Liquidity-based routing fee in millionths of a routed amount. +/// In other words, 10000 is 1%. +#[no_mangle] +pub extern "C" fn RoutingFees_set_proportional_millionths(this_ptr: &mut RoutingFees, mut val: u32) { + unsafe { &mut *this_ptr.inner }.proportional_millionths = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn RoutingFees_new(mut base_msat_arg: u32, mut proportional_millionths_arg: u32) -> RoutingFees { + RoutingFees { inner: Box::into_raw(Box::new(nativeRoutingFees { + base_msat: base_msat_arg, + proportional_millionths: proportional_millionths_arg, + })), is_owned: true } +} +#[no_mangle] +pub extern "C" fn RoutingFees_read(ser: crate::c_types::u8slice) -> RoutingFees { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + RoutingFees { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + RoutingFees { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn RoutingFees_write(obj: *const RoutingFees) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} + +use lightning::routing::network_graph::NodeAnnouncementInfo as nativeNodeAnnouncementInfoImport; +type nativeNodeAnnouncementInfo = nativeNodeAnnouncementInfoImport; + +/// Information received in the latest node_announcement from this node. +#[must_use] +#[repr(C)] +pub struct NodeAnnouncementInfo { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNodeAnnouncementInfo, + pub is_owned: bool, +} + +impl Drop for NodeAnnouncementInfo { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_free(this_ptr: NodeAnnouncementInfo) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NodeAnnouncementInfo_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeAnnouncementInfo); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NodeAnnouncementInfo { + pub(crate) fn take_ptr(mut self) -> *mut nativeNodeAnnouncementInfo { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// When the last known update to the node state was issued. +/// Value is opaque, as set in the announcement. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_get_last_update(this_ptr: &NodeAnnouncementInfo) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.last_update; + (*inner_val) +} +/// When the last known update to the node state was issued. +/// Value is opaque, as set in the announcement. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_set_last_update(this_ptr: &mut NodeAnnouncementInfo, mut val: u32) { + unsafe { &mut *this_ptr.inner }.last_update = val; +} +/// Color assigned to the node +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_get_rgb(this_ptr: &NodeAnnouncementInfo) -> *const [u8; 3] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.rgb; + &(*inner_val) +} +/// Color assigned to the node +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_set_rgb(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::c_types::ThreeBytes) { + unsafe { &mut *this_ptr.inner }.rgb = val.data; +} +/// Moniker assigned to the node. +/// May be invalid or malicious (eg control chars), +/// should not be exposed to the user. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_get_alias(this_ptr: &NodeAnnouncementInfo) -> *const [u8; 32] { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.alias; + &(*inner_val) +} +/// Moniker assigned to the node. +/// May be invalid or malicious (eg control chars), +/// should not be exposed to the user. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_set_alias(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *this_ptr.inner }.alias = val.data; +} +/// Internet-level addresses via which one can connect to the node +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_set_addresses(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::c_types::derived::CVec_NetAddressZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_native() }); }; + unsafe { &mut *this_ptr.inner }.addresses = local_val; +} +/// An initial announcement of the node +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_get_announcement_message(this_ptr: &NodeAnnouncementInfo) -> crate::ln::msgs::NodeAnnouncement { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.announcement_message; + let mut local_inner_val = crate::ln::msgs::NodeAnnouncement { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// An initial announcement of the node +/// Mostly redundant with the data we store in fields explicitly. +/// Everything else is useful only for sending out for initial routing sync. +/// Not stored if contains excess data to prevent DoS. +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_set_announcement_message(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::ln::msgs::NodeAnnouncement) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.announcement_message = local_val; +} +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_write(obj: *const NodeAnnouncementInfo) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn NodeAnnouncementInfo_read(ser: crate::c_types::u8slice) -> NodeAnnouncementInfo { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + NodeAnnouncementInfo { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + NodeAnnouncementInfo { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::routing::network_graph::NodeInfo as nativeNodeInfoImport; +type nativeNodeInfo = nativeNodeInfoImport; + +/// Details about a node in the network, known from the network announcement. +#[must_use] +#[repr(C)] +pub struct NodeInfo { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeNodeInfo, + pub is_owned: bool, +} + +impl Drop for NodeInfo { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn NodeInfo_free(this_ptr: NodeInfo) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn NodeInfo_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeInfo); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl NodeInfo { + pub(crate) fn take_ptr(mut self) -> *mut nativeNodeInfo { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// All valid channels a node has announced +#[no_mangle] +pub extern "C" fn NodeInfo_set_channels(this_ptr: &mut NodeInfo, mut val: crate::c_types::derived::CVec_u64Z) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); }; + unsafe { &mut *this_ptr.inner }.channels = local_val; +} +/// Lowest fees enabling routing via any of the enabled, known channels to a node. +/// The two fields (flat and proportional fee) are independent, +/// meaning they don't have to refer to the same channel. +#[no_mangle] +pub extern "C" fn NodeInfo_get_lowest_inbound_channel_fees(this_ptr: &NodeInfo) -> crate::routing::network_graph::RoutingFees { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.lowest_inbound_channel_fees; + let mut local_inner_val = crate::routing::network_graph::RoutingFees { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// Lowest fees enabling routing via any of the enabled, known channels to a node. +/// The two fields (flat and proportional fee) are independent, +/// meaning they don't have to refer to the same channel. +#[no_mangle] +pub extern "C" fn NodeInfo_set_lowest_inbound_channel_fees(this_ptr: &mut NodeInfo, mut val: crate::routing::network_graph::RoutingFees) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.lowest_inbound_channel_fees = local_val; +} +/// More information about a node from node_announcement. +/// Optional because we store a Node entry after learning about it from +/// a channel announcement, but before receiving a node announcement. +#[no_mangle] +pub extern "C" fn NodeInfo_get_announcement_info(this_ptr: &NodeInfo) -> crate::routing::network_graph::NodeAnnouncementInfo { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.announcement_info; + let mut local_inner_val = crate::routing::network_graph::NodeAnnouncementInfo { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false }; + local_inner_val +} +/// More information about a node from node_announcement. +/// Optional because we store a Node entry after learning about it from +/// a channel announcement, but before receiving a node announcement. +#[no_mangle] +pub extern "C" fn NodeInfo_set_announcement_info(this_ptr: &mut NodeInfo, mut val: crate::routing::network_graph::NodeAnnouncementInfo) { + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + unsafe { &mut *this_ptr.inner }.announcement_info = local_val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn NodeInfo_new(mut channels_arg: crate::c_types::derived::CVec_u64Z, mut lowest_inbound_channel_fees_arg: crate::routing::network_graph::RoutingFees, mut announcement_info_arg: crate::routing::network_graph::NodeAnnouncementInfo) -> NodeInfo { + let mut local_channels_arg = Vec::new(); for mut item in channels_arg.into_rust().drain(..) { local_channels_arg.push( { item }); }; + let mut local_lowest_inbound_channel_fees_arg = if lowest_inbound_channel_fees_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(lowest_inbound_channel_fees_arg.take_ptr()) } }) }; + let mut local_announcement_info_arg = if announcement_info_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(announcement_info_arg.take_ptr()) } }) }; + NodeInfo { inner: Box::into_raw(Box::new(nativeNodeInfo { + channels: local_channels_arg, + lowest_inbound_channel_fees: local_lowest_inbound_channel_fees_arg, + announcement_info: local_announcement_info_arg, + })), is_owned: true } +} +#[no_mangle] +pub extern "C" fn NodeInfo_write(obj: *const NodeInfo) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn NodeInfo_read(ser: crate::c_types::u8slice) -> NodeInfo { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + NodeInfo { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + NodeInfo { inner: std::ptr::null_mut(), is_owned: true } + } +} +#[no_mangle] +pub extern "C" fn NetworkGraph_write(obj: *const NetworkGraph) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn NetworkGraph_read(ser: crate::c_types::u8slice) -> NetworkGraph { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + NetworkGraph { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + NetworkGraph { inner: std::ptr::null_mut(), is_owned: true } + } +} +/// Creates a new, empty, network graph. +#[must_use] +#[no_mangle] +pub extern "C" fn NetworkGraph_new() -> crate::routing::network_graph::NetworkGraph { + let mut ret = lightning::routing::network_graph::NetworkGraph::new(); + crate::routing::network_graph::NetworkGraph { inner: Box::into_raw(Box::new(ret)), is_owned: true } +} + +/// Close a channel if a corresponding HTLC fail was sent. +/// If permanent, removes a channel from the local storage. +/// May cause the removal of nodes too, if this was their last channel. +/// If not permanent, makes channels unavailable for routing. +#[no_mangle] +pub extern "C" fn NetworkGraph_close_channel_from_update(this_arg: &mut NetworkGraph, mut short_channel_id: u64, mut is_permanent: bool) { + unsafe { &mut (*(this_arg.inner as *mut nativeNetworkGraph)) }.close_channel_from_update(short_channel_id, is_permanent) +} + diff --git a/lightning-c-bindings/src/routing/router.rs b/lightning-c-bindings/src/routing/router.rs new file mode 100644 index 000000000..978c24b41 --- /dev/null +++ b/lightning-c-bindings/src/routing/router.rs @@ -0,0 +1,318 @@ +//! The top-level routing/network map tracking logic lives here. +//! +//! You probably want to create a NetGraphMsgHandler and use that as your RoutingMessageHandler and then +//! interrogate it to get routes for your own payments. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::routing::router::RouteHop as nativeRouteHopImport; +type nativeRouteHop = nativeRouteHopImport; + +/// A hop in a route +#[must_use] +#[repr(C)] +pub struct RouteHop { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeRouteHop, + pub is_owned: bool, +} + +impl Drop for RouteHop { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn RouteHop_free(this_ptr: RouteHop) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn RouteHop_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteHop); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl RouteHop { + pub(crate) fn take_ptr(mut self) -> *mut nativeRouteHop { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for RouteHop { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn RouteHop_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRouteHop)).clone() })) as *mut c_void +} +/// The node_id of the node at this hop. +#[no_mangle] +pub extern "C" fn RouteHop_get_pubkey(this_ptr: &RouteHop) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.pubkey; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The node_id of the node at this hop. +#[no_mangle] +pub extern "C" fn RouteHop_set_pubkey(this_ptr: &mut RouteHop, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.pubkey = val.into_rust(); +} +/// The channel that should be used from the previous hop to reach this node. +#[no_mangle] +pub extern "C" fn RouteHop_get_short_channel_id(this_ptr: &RouteHop) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id; + (*inner_val) +} +/// The channel that should be used from the previous hop to reach this node. +#[no_mangle] +pub extern "C" fn RouteHop_set_short_channel_id(this_ptr: &mut RouteHop, mut val: u64) { + unsafe { &mut *this_ptr.inner }.short_channel_id = val; +} +/// The fee taken on this hop. For the last hop, this should be the full value of the payment. +#[no_mangle] +pub extern "C" fn RouteHop_get_fee_msat(this_ptr: &RouteHop) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_msat; + (*inner_val) +} +/// The fee taken on this hop. For the last hop, this should be the full value of the payment. +#[no_mangle] +pub extern "C" fn RouteHop_set_fee_msat(this_ptr: &mut RouteHop, mut val: u64) { + unsafe { &mut *this_ptr.inner }.fee_msat = val; +} +/// The CLTV delta added for this hop. For the last hop, this should be the full CLTV value +/// expected at the destination, in excess of the current block height. +#[no_mangle] +pub extern "C" fn RouteHop_get_cltv_expiry_delta(this_ptr: &RouteHop) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry_delta; + (*inner_val) +} +/// The CLTV delta added for this hop. For the last hop, this should be the full CLTV value +/// expected at the destination, in excess of the current block height. +#[no_mangle] +pub extern "C" fn RouteHop_set_cltv_expiry_delta(this_ptr: &mut RouteHop, mut val: u32) { + unsafe { &mut *this_ptr.inner }.cltv_expiry_delta = val; +} + +use lightning::routing::router::Route as nativeRouteImport; +type nativeRoute = nativeRouteImport; + +/// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP, +/// it can take multiple paths. Each path is composed of one or more hops through the network. +#[must_use] +#[repr(C)] +pub struct Route { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeRoute, + pub is_owned: bool, +} + +impl Drop for Route { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn Route_free(this_ptr: Route) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn Route_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRoute); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl Route { + pub(crate) fn take_ptr(mut self) -> *mut nativeRoute { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for Route { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Route_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRoute)).clone() })) as *mut c_void +} +/// The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the +/// last RouteHop in each path must be the same. +/// Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the +/// destination. Thus, this must always be at least length one. While the maximum length of any +/// given path is variable, keeping the length of any path to less than 20 should currently +/// ensure it is viable. +#[no_mangle] +pub extern "C" fn Route_set_paths(this_ptr: &mut Route, mut val: crate::c_types::derived::CVec_CVec_RouteHopZZ) { + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { let mut local_val_0 = Vec::new(); for mut item in item.into_rust().drain(..) { local_val_0.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; local_val_0 }); }; + unsafe { &mut *this_ptr.inner }.paths = local_val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn Route_new(mut paths_arg: crate::c_types::derived::CVec_CVec_RouteHopZZ) -> Route { + let mut local_paths_arg = Vec::new(); for mut item in paths_arg.into_rust().drain(..) { local_paths_arg.push( { let mut local_paths_arg_0 = Vec::new(); for mut item in item.into_rust().drain(..) { local_paths_arg_0.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; local_paths_arg_0 }); }; + Route { inner: Box::into_raw(Box::new(nativeRoute { + paths: local_paths_arg, + })), is_owned: true } +} +#[no_mangle] +pub extern "C" fn Route_write(obj: *const Route) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn Route_read(ser: crate::c_types::u8slice) -> Route { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + Route { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + Route { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::routing::router::RouteHint as nativeRouteHintImport; +type nativeRouteHint = nativeRouteHintImport; + +/// A channel descriptor which provides a last-hop route to get_route +#[must_use] +#[repr(C)] +pub struct RouteHint { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeRouteHint, + pub is_owned: bool, +} + +impl Drop for RouteHint { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn RouteHint_free(this_ptr: RouteHint) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn RouteHint_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteHint); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl RouteHint { + pub(crate) fn take_ptr(mut self) -> *mut nativeRouteHint { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +/// The node_id of the non-target end of the route +#[no_mangle] +pub extern "C" fn RouteHint_get_src_node_id(this_ptr: &RouteHint) -> crate::c_types::PublicKey { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.src_node_id; + crate::c_types::PublicKey::from_rust(&(*inner_val)) +} +/// The node_id of the non-target end of the route +#[no_mangle] +pub extern "C" fn RouteHint_set_src_node_id(this_ptr: &mut RouteHint, mut val: crate::c_types::PublicKey) { + unsafe { &mut *this_ptr.inner }.src_node_id = val.into_rust(); +} +/// The short_channel_id of this channel +#[no_mangle] +pub extern "C" fn RouteHint_get_short_channel_id(this_ptr: &RouteHint) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id; + (*inner_val) +} +/// The short_channel_id of this channel +#[no_mangle] +pub extern "C" fn RouteHint_set_short_channel_id(this_ptr: &mut RouteHint, mut val: u64) { + unsafe { &mut *this_ptr.inner }.short_channel_id = val; +} +/// The fees which must be paid to use this channel +#[no_mangle] +pub extern "C" fn RouteHint_get_fees(this_ptr: &RouteHint) -> crate::routing::network_graph::RoutingFees { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fees; + crate::routing::network_graph::RoutingFees { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// The fees which must be paid to use this channel +#[no_mangle] +pub extern "C" fn RouteHint_set_fees(this_ptr: &mut RouteHint, mut val: crate::routing::network_graph::RoutingFees) { + unsafe { &mut *this_ptr.inner }.fees = *unsafe { Box::from_raw(val.take_ptr()) }; +} +/// The difference in CLTV values between this node and the next node. +#[no_mangle] +pub extern "C" fn RouteHint_get_cltv_expiry_delta(this_ptr: &RouteHint) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry_delta; + (*inner_val) +} +/// The difference in CLTV values between this node and the next node. +#[no_mangle] +pub extern "C" fn RouteHint_set_cltv_expiry_delta(this_ptr: &mut RouteHint, mut val: u16) { + unsafe { &mut *this_ptr.inner }.cltv_expiry_delta = val; +} +/// The minimum value, in msat, which must be relayed to the next hop. +#[no_mangle] +pub extern "C" fn RouteHint_get_htlc_minimum_msat(this_ptr: &RouteHint) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat; + (*inner_val) +} +/// The minimum value, in msat, which must be relayed to the next hop. +#[no_mangle] +pub extern "C" fn RouteHint_set_htlc_minimum_msat(this_ptr: &mut RouteHint, mut val: u64) { + unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn RouteHint_new(mut src_node_id_arg: crate::c_types::PublicKey, mut short_channel_id_arg: u64, mut fees_arg: crate::routing::network_graph::RoutingFees, mut cltv_expiry_delta_arg: u16, mut htlc_minimum_msat_arg: u64) -> RouteHint { + RouteHint { inner: Box::into_raw(Box::new(nativeRouteHint { + src_node_id: src_node_id_arg.into_rust(), + short_channel_id: short_channel_id_arg, + fees: *unsafe { Box::from_raw(fees_arg.take_ptr()) }, + cltv_expiry_delta: cltv_expiry_delta_arg, + htlc_minimum_msat: htlc_minimum_msat_arg, + })), is_owned: true } +} +/// Gets a route from us to the given target node. +/// +/// Extra routing hops between known nodes and the target will be used if they are included in +/// last_hops. +/// +/// If some channels aren't announced, it may be useful to fill in a first_hops with the +/// results from a local ChannelManager::list_usable_channels() call. If it is filled in, our +/// view of our local channels (from net_graph_msg_handler) will be ignored, and only those in first_hops +/// will be used. +/// +/// Panics if first_hops contains channels without short_channel_ids +/// (ChannelManager::list_usable_channels will never include such channels). +/// +/// The fees on channels from us to next-hops are ignored (as they are assumed to all be +/// equal), however the enabled/disabled bit on such channels as well as the htlc_minimum_msat +/// *is* checked as they may change based on the receiving node. +#[no_mangle] +pub extern "C" fn get_route(our_node_id: crate::c_types::PublicKey, network: &crate::routing::network_graph::NetworkGraph, target: crate::c_types::PublicKey, mut first_hops: *mut crate::c_types::derived::CVec_ChannelDetailsZ, mut last_hops: crate::c_types::derived::CVec_RouteHintZ, mut final_value_msat: u64, mut final_cltv: u32, mut logger: crate::util::logger::Logger) -> crate::c_types::derived::CResult_RouteLightningErrorZ { + let mut local_first_hops_base = if first_hops.is_null() { None } else { Some( { let mut local_first_hops_0 = Vec::new(); for mut item in unsafe { &mut *first_hops }.as_slice().iter() { local_first_hops_0.push( { unsafe { &*item.inner } }); }; local_first_hops_0 }) }; let mut local_first_hops = local_first_hops_base.as_ref().map(|a| &a[..]); + let mut local_last_hops = Vec::new(); for mut item in last_hops.as_slice().iter() { local_last_hops.push( { unsafe { &*item.inner } }); }; + let mut ret = lightning::routing::router::get_route(&our_node_id.into_rust(), unsafe { &*network.inner }, &target.into_rust(), local_first_hops, &local_last_hops[..], final_value_msat, final_cltv, logger); + let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::routing::router::Route { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::LightningError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_ret +} + diff --git a/lightning-c-bindings/src/util/config.rs b/lightning-c-bindings/src/util/config.rs new file mode 100644 index 000000000..53a7d9402 --- /dev/null +++ b/lightning-c-bindings/src/util/config.rs @@ -0,0 +1,687 @@ +//! Various user-configurable channel limits and settings which ChannelManager +//! applies for you. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + + +use lightning::util::config::ChannelHandshakeConfig as nativeChannelHandshakeConfigImport; +type nativeChannelHandshakeConfig = nativeChannelHandshakeConfigImport; + +/// Configuration we set when applicable. +/// +/// Default::default() provides sane defaults. +#[must_use] +#[repr(C)] +pub struct ChannelHandshakeConfig { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelHandshakeConfig, + pub is_owned: bool, +} + +impl Drop for ChannelHandshakeConfig { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_free(this_ptr: ChannelHandshakeConfig) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelHandshakeConfig_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelHandshakeConfig); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelHandshakeConfig { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelHandshakeConfig { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelHandshakeConfig { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelHandshakeConfig_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelHandshakeConfig)).clone() })) as *mut c_void +} +/// Confirmations we will wait for before considering the channel locked in. +/// Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the +/// equivalent limit applied to outbound channels). +/// +/// Default value: 6. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_get_minimum_depth(this_ptr: &ChannelHandshakeConfig) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.minimum_depth; + (*inner_val) +} +/// Confirmations we will wait for before considering the channel locked in. +/// Applied only for inbound channels (see ChannelHandshakeLimits::max_minimum_depth for the +/// equivalent limit applied to outbound channels). +/// +/// Default value: 6. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_set_minimum_depth(this_ptr: &mut ChannelHandshakeConfig, mut val: u32) { + unsafe { &mut *this_ptr.inner }.minimum_depth = val; +} +/// Set to the amount of time we require our counterparty to wait to claim their money. +/// +/// It's one of the main parameter of our security model. We (or one of our watchtowers) MUST +/// be online to check for peer having broadcast a revoked transaction to steal our funds +/// at least once every our_to_self_delay blocks. +/// +/// Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in +/// case of an honest unilateral channel close, which implicitly decrease the economic value of +/// our channel. +/// +/// Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel +/// opening so you can tweak config to ask for more security, not less. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: &ChannelHandshakeConfig) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.our_to_self_delay; + (*inner_val) +} +/// Set to the amount of time we require our counterparty to wait to claim their money. +/// +/// It's one of the main parameter of our security model. We (or one of our watchtowers) MUST +/// be online to check for peer having broadcast a revoked transaction to steal our funds +/// at least once every our_to_self_delay blocks. +/// +/// Meanwhile, asking for a too high delay, we bother peer to freeze funds for nothing in +/// case of an honest unilateral channel close, which implicitly decrease the economic value of +/// our channel. +/// +/// Default value: BREAKDOWN_TIMEOUT (currently 144), we enforce it as a minimum at channel +/// opening so you can tweak config to ask for more security, not less. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: &mut ChannelHandshakeConfig, mut val: u16) { + unsafe { &mut *this_ptr.inner }.our_to_self_delay = val; +} +/// Set to the smallest value HTLC we will accept to process. +/// +/// This value is sent to our counterparty on channel-open and we close the channel any time +/// our counterparty misbehaves by sending us an HTLC with a value smaller than this. +/// +/// Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required +/// by the protocol. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: &ChannelHandshakeConfig) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.our_htlc_minimum_msat; + (*inner_val) +} +/// Set to the smallest value HTLC we will accept to process. +/// +/// This value is sent to our counterparty on channel-open and we close the channel any time +/// our counterparty misbehaves by sending us an HTLC with a value smaller than this. +/// +/// Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required +/// by the protocol. +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: &mut ChannelHandshakeConfig, mut val: u64) { + unsafe { &mut *this_ptr.inner }.our_htlc_minimum_msat = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_new(mut minimum_depth_arg: u32, mut our_to_self_delay_arg: u16, mut our_htlc_minimum_msat_arg: u64) -> ChannelHandshakeConfig { + ChannelHandshakeConfig { inner: Box::into_raw(Box::new(nativeChannelHandshakeConfig { + minimum_depth: minimum_depth_arg, + our_to_self_delay: our_to_self_delay_arg, + our_htlc_minimum_msat: our_htlc_minimum_msat_arg, + })), is_owned: true } +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelHandshakeConfig_default() -> ChannelHandshakeConfig { + ChannelHandshakeConfig { inner: Box::into_raw(Box::new(Default::default())), is_owned: true } +} + +use lightning::util::config::ChannelHandshakeLimits as nativeChannelHandshakeLimitsImport; +type nativeChannelHandshakeLimits = nativeChannelHandshakeLimitsImport; + +/// Optional channel limits which are applied during channel creation. +/// +/// These limits are only applied to our counterparty's limits, not our own. +/// +/// Use 0/::max_value() as appropriate to skip checking. +/// +/// Provides sane defaults for most configurations. +/// +/// Most additional limits are disabled except those with which specify a default in individual +/// field documentation. Note that this may result in barely-usable channels, but since they +/// are applied mostly only to incoming channels that's not much of a problem. +#[must_use] +#[repr(C)] +pub struct ChannelHandshakeLimits { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelHandshakeLimits, + pub is_owned: bool, +} + +impl Drop for ChannelHandshakeLimits { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_free(this_ptr: ChannelHandshakeLimits) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelHandshakeLimits_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelHandshakeLimits); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelHandshakeLimits { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelHandshakeLimits { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelHandshakeLimits { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelHandshakeLimits_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelHandshakeLimits)).clone() })) as *mut c_void +} +/// Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so +/// only applies to inbound channels. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.min_funding_satoshis; + (*inner_val) +} +/// Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so +/// only applies to inbound channels. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.min_funding_satoshis = val; +} +/// The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows +/// you to limit the maximum minimum-size they can require. +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_htlc_minimum_msat; + (*inner_val) +} +/// The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows +/// you to limit the maximum minimum-size they can require. +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.max_htlc_minimum_msat = val; +} +/// The remote node sets a limit on the maximum value of pending HTLCs to them at any given +/// time to limit their funds exposure to HTLCs. This allows you to set a minimum such value. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.min_max_htlc_value_in_flight_msat; + (*inner_val) +} +/// The remote node sets a limit on the maximum value of pending HTLCs to them at any given +/// time to limit their funds exposure to HTLCs. This allows you to set a minimum such value. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.min_max_htlc_value_in_flight_msat = val; +} +/// The remote node will require we keep a certain amount in direct payment to ourselves at all +/// time, ensuring that we are able to be punished if we broadcast an old state. This allows to +/// you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs). +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_channel_reserve_satoshis; + (*inner_val) +} +/// The remote node will require we keep a certain amount in direct payment to ourselves at all +/// time, ensuring that we are able to be punished if we broadcast an old state. This allows to +/// you limit the amount which we will have to keep to ourselves (and cannot use for HTLCs). +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.max_channel_reserve_satoshis = val; +} +/// The remote node sets a limit on the maximum number of pending HTLCs to them at any given +/// time. This allows you to set a minimum such value. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: &ChannelHandshakeLimits) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.min_max_accepted_htlcs; + (*inner_val) +} +/// The remote node sets a limit on the maximum number of pending HTLCs to them at any given +/// time. This allows you to set a minimum such value. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: &mut ChannelHandshakeLimits, mut val: u16) { + unsafe { &mut *this_ptr.inner }.min_max_accepted_htlcs = val; +} +/// Outputs below a certain value will not be added to on-chain transactions. The dust value is +/// required to always be higher than this value so this only applies to HTLC outputs (and +/// potentially to-self outputs before any payments have been made). +/// Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. +/// This setting allows you to set a minimum dust limit for their commitment transactions, +/// reflecting the reality that tiny outputs are not considered standard transactions and will +/// not propagate through the Bitcoin network. +/// +/// Default value: 546, the current dust limit on the Bitcoin network. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_min_dust_limit_satoshis(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.min_dust_limit_satoshis; + (*inner_val) +} +/// Outputs below a certain value will not be added to on-chain transactions. The dust value is +/// required to always be higher than this value so this only applies to HTLC outputs (and +/// potentially to-self outputs before any payments have been made). +/// Thus, HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. +/// This setting allows you to set a minimum dust limit for their commitment transactions, +/// reflecting the reality that tiny outputs are not considered standard transactions and will +/// not propagate through the Bitcoin network. +/// +/// Default value: 546, the current dust limit on the Bitcoin network. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_min_dust_limit_satoshis(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.min_dust_limit_satoshis = val; +} +/// Maximum allowed threshold above which outputs will not be generated in their commitment +/// transactions. +/// HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_max_dust_limit_satoshis(this_ptr: &ChannelHandshakeLimits) -> u64 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_dust_limit_satoshis; + (*inner_val) +} +/// Maximum allowed threshold above which outputs will not be generated in their commitment +/// transactions. +/// HTLCs below this amount plus HTLC transaction fees are not enforceable on-chain. +/// +/// Default value: u64::max_value. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_max_dust_limit_satoshis(this_ptr: &mut ChannelHandshakeLimits, mut val: u64) { + unsafe { &mut *this_ptr.inner }.max_dust_limit_satoshis = val; +} +/// Before a channel is usable the funding transaction will need to be confirmed by at least a +/// certain number of blocks, specified by the node which is not the funder (as the funder can +/// assume they aren't going to double-spend themselves). +/// This config allows you to set a limit on the maximum amount of time to wait. +/// +/// Default value: 144, or roughly one day and only applies to outbound channels. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: &ChannelHandshakeLimits) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_minimum_depth; + (*inner_val) +} +/// Before a channel is usable the funding transaction will need to be confirmed by at least a +/// certain number of blocks, specified by the node which is not the funder (as the funder can +/// assume they aren't going to double-spend themselves). +/// This config allows you to set a limit on the maximum amount of time to wait. +/// +/// Default value: 144, or roughly one day and only applies to outbound channels. +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: &mut ChannelHandshakeLimits, mut val: u32) { + unsafe { &mut *this_ptr.inner }.max_minimum_depth = val; +} +/// Set to force the incoming channel to match our announced channel preference in +/// ChannelConfig. +/// +/// Default value: true, to make the default that no announced channels are possible (which is +/// appropriate for any nodes which are not online very reliably). +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: &ChannelHandshakeLimits) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.force_announced_channel_preference; + (*inner_val) +} +/// Set to force the incoming channel to match our announced channel preference in +/// ChannelConfig. +/// +/// Default value: true, to make the default that no announced channels are possible (which is +/// appropriate for any nodes which are not online very reliably). +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: &mut ChannelHandshakeLimits, mut val: bool) { + unsafe { &mut *this_ptr.inner }.force_announced_channel_preference = val; +} +/// Set to the amount of time we're willing to wait to claim money back to us. +/// +/// Not checking this value would be a security issue, as our peer would be able to set it to +/// max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time. +/// +/// Default value: MAX_LOCAL_BREAKDOWN_TIMEOUT (1008), which we also enforce as a maximum value +/// so you can tweak config to reduce the loss of having useless locked funds (if your peer accepts) +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: &ChannelHandshakeLimits) -> u16 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.their_to_self_delay; + (*inner_val) +} +/// Set to the amount of time we're willing to wait to claim money back to us. +/// +/// Not checking this value would be a security issue, as our peer would be able to set it to +/// max relative lock-time (a year) and we would \"lose\" money as it would be locked for a long time. +/// +/// Default value: MAX_LOCAL_BREAKDOWN_TIMEOUT (1008), which we also enforce as a maximum value +/// so you can tweak config to reduce the loss of having useless locked funds (if your peer accepts) +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: &mut ChannelHandshakeLimits, mut val: u16) { + unsafe { &mut *this_ptr.inner }.their_to_self_delay = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_new(mut min_funding_satoshis_arg: u64, mut max_htlc_minimum_msat_arg: u64, mut min_max_htlc_value_in_flight_msat_arg: u64, mut max_channel_reserve_satoshis_arg: u64, mut min_max_accepted_htlcs_arg: u16, mut min_dust_limit_satoshis_arg: u64, mut max_dust_limit_satoshis_arg: u64, mut max_minimum_depth_arg: u32, mut force_announced_channel_preference_arg: bool, mut their_to_self_delay_arg: u16) -> ChannelHandshakeLimits { + ChannelHandshakeLimits { inner: Box::into_raw(Box::new(nativeChannelHandshakeLimits { + min_funding_satoshis: min_funding_satoshis_arg, + max_htlc_minimum_msat: max_htlc_minimum_msat_arg, + min_max_htlc_value_in_flight_msat: min_max_htlc_value_in_flight_msat_arg, + max_channel_reserve_satoshis: max_channel_reserve_satoshis_arg, + min_max_accepted_htlcs: min_max_accepted_htlcs_arg, + min_dust_limit_satoshis: min_dust_limit_satoshis_arg, + max_dust_limit_satoshis: max_dust_limit_satoshis_arg, + max_minimum_depth: max_minimum_depth_arg, + force_announced_channel_preference: force_announced_channel_preference_arg, + their_to_self_delay: their_to_self_delay_arg, + })), is_owned: true } +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelHandshakeLimits_default() -> ChannelHandshakeLimits { + ChannelHandshakeLimits { inner: Box::into_raw(Box::new(Default::default())), is_owned: true } +} + +use lightning::util::config::ChannelConfig as nativeChannelConfigImport; +type nativeChannelConfig = nativeChannelConfigImport; + +/// Options which apply on a per-channel basis and may change at runtime or based on negotiation +/// with our counterparty. +#[must_use] +#[repr(C)] +pub struct ChannelConfig { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeChannelConfig, + pub is_owned: bool, +} + +impl Drop for ChannelConfig { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn ChannelConfig_free(this_ptr: ChannelConfig) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn ChannelConfig_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelConfig); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl ChannelConfig { + pub(crate) fn take_ptr(mut self) -> *mut nativeChannelConfig { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for ChannelConfig { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ChannelConfig_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelConfig)).clone() })) as *mut c_void +} +/// Amount (in millionths of a satoshi) the channel will charge per transferred satoshi. +/// This may be allowed to change at runtime in a later update, however doing so must result in +/// update messages sent to notify all nodes of our updated relay fee. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelConfig_get_fee_proportional_millionths(this_ptr: &ChannelConfig) -> u32 { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_proportional_millionths; + (*inner_val) +} +/// Amount (in millionths of a satoshi) the channel will charge per transferred satoshi. +/// This may be allowed to change at runtime in a later update, however doing so must result in +/// update messages sent to notify all nodes of our updated relay fee. +/// +/// Default value: 0. +#[no_mangle] +pub extern "C" fn ChannelConfig_set_fee_proportional_millionths(this_ptr: &mut ChannelConfig, mut val: u32) { + unsafe { &mut *this_ptr.inner }.fee_proportional_millionths = val; +} +/// Set to announce the channel publicly and notify all nodes that they can route via this +/// channel. +/// +/// This should only be set to true for nodes which expect to be online reliably. +/// +/// As the node which funds a channel picks this value this will only apply for new outbound +/// channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set. +/// +/// This cannot be changed after the initial channel handshake. +/// +/// Default value: false. +#[no_mangle] +pub extern "C" fn ChannelConfig_get_announced_channel(this_ptr: &ChannelConfig) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.announced_channel; + (*inner_val) +} +/// Set to announce the channel publicly and notify all nodes that they can route via this +/// channel. +/// +/// This should only be set to true for nodes which expect to be online reliably. +/// +/// As the node which funds a channel picks this value this will only apply for new outbound +/// channels unless ChannelHandshakeLimits::force_announced_channel_preferences is set. +/// +/// This cannot be changed after the initial channel handshake. +/// +/// Default value: false. +#[no_mangle] +pub extern "C" fn ChannelConfig_set_announced_channel(this_ptr: &mut ChannelConfig, mut val: bool) { + unsafe { &mut *this_ptr.inner }.announced_channel = val; +} +/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty +/// supports it, they will then enforce the mutual-close output to us matches what we provided +/// at intialization, preventing us from closing to an alternate pubkey. +/// +/// This is set to true by default to provide a slight increase in security, though ultimately +/// any attacker who is able to take control of a channel can just as easily send the funds via +/// lightning payments, so we never require that our counterparties support this option. +/// +/// This cannot be changed after a channel has been initialized. +/// +/// Default value: true. +#[no_mangle] +pub extern "C" fn ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: &ChannelConfig) -> bool { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commit_upfront_shutdown_pubkey; + (*inner_val) +} +/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty +/// supports it, they will then enforce the mutual-close output to us matches what we provided +/// at intialization, preventing us from closing to an alternate pubkey. +/// +/// This is set to true by default to provide a slight increase in security, though ultimately +/// any attacker who is able to take control of a channel can just as easily send the funds via +/// lightning payments, so we never require that our counterparties support this option. +/// +/// This cannot be changed after a channel has been initialized. +/// +/// Default value: true. +#[no_mangle] +pub extern "C" fn ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: &mut ChannelConfig, mut val: bool) { + unsafe { &mut *this_ptr.inner }.commit_upfront_shutdown_pubkey = val; +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelConfig_new(mut fee_proportional_millionths_arg: u32, mut announced_channel_arg: bool, mut commit_upfront_shutdown_pubkey_arg: bool) -> ChannelConfig { + ChannelConfig { inner: Box::into_raw(Box::new(nativeChannelConfig { + fee_proportional_millionths: fee_proportional_millionths_arg, + announced_channel: announced_channel_arg, + commit_upfront_shutdown_pubkey: commit_upfront_shutdown_pubkey_arg, + })), is_owned: true } +} +#[must_use] +#[no_mangle] +pub extern "C" fn ChannelConfig_default() -> ChannelConfig { + ChannelConfig { inner: Box::into_raw(Box::new(Default::default())), is_owned: true } +} +#[no_mangle] +pub extern "C" fn ChannelConfig_write(obj: *const ChannelConfig) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) +} +#[no_mangle] +pub extern "C" fn ChannelConfig_read(ser: crate::c_types::u8slice) -> ChannelConfig { + if let Ok(res) = crate::c_types::deserialize_obj(ser) { + ChannelConfig { inner: Box::into_raw(Box::new(res)), is_owned: true } + } else { + ChannelConfig { inner: std::ptr::null_mut(), is_owned: true } + } +} + +use lightning::util::config::UserConfig as nativeUserConfigImport; +type nativeUserConfig = nativeUserConfigImport; + +/// Top-level config which holds ChannelHandshakeLimits and ChannelConfig. +/// +/// Default::default() provides sane defaults for most configurations +/// (but currently with 0 relay fees!) +#[must_use] +#[repr(C)] +pub struct UserConfig { + /// Nearly everyhwere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeUserConfig, + pub is_owned: bool, +} + +impl Drop for UserConfig { + fn drop(&mut self) { + if self.is_owned && !self.inner.is_null() { + let _ = unsafe { Box::from_raw(self.inner) }; + } + } +} +#[no_mangle] +pub extern "C" fn UserConfig_free(this_ptr: UserConfig) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +extern "C" fn UserConfig_free_void(this_ptr: *mut c_void) { + unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUserConfig); } +} +#[allow(unused)] +/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy +impl UserConfig { + pub(crate) fn take_ptr(mut self) -> *mut nativeUserConfig { + assert!(self.is_owned); + let ret = self.inner; + self.inner = std::ptr::null_mut(); + ret + } +} +impl Clone for UserConfig { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn UserConfig_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUserConfig)).clone() })) as *mut c_void +} +/// Channel config that we propose to our counterparty. +#[no_mangle] +pub extern "C" fn UserConfig_get_own_channel_config(this_ptr: &UserConfig) -> crate::util::config::ChannelHandshakeConfig { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.own_channel_config; + crate::util::config::ChannelHandshakeConfig { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// Channel config that we propose to our counterparty. +#[no_mangle] +pub extern "C" fn UserConfig_set_own_channel_config(this_ptr: &mut UserConfig, mut val: crate::util::config::ChannelHandshakeConfig) { + unsafe { &mut *this_ptr.inner }.own_channel_config = *unsafe { Box::from_raw(val.take_ptr()) }; +} +/// Limits applied to our counterparty's proposed channel config settings. +#[no_mangle] +pub extern "C" fn UserConfig_get_peer_channel_config_limits(this_ptr: &UserConfig) -> crate::util::config::ChannelHandshakeLimits { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.peer_channel_config_limits; + crate::util::config::ChannelHandshakeLimits { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// Limits applied to our counterparty's proposed channel config settings. +#[no_mangle] +pub extern "C" fn UserConfig_set_peer_channel_config_limits(this_ptr: &mut UserConfig, mut val: crate::util::config::ChannelHandshakeLimits) { + unsafe { &mut *this_ptr.inner }.peer_channel_config_limits = *unsafe { Box::from_raw(val.take_ptr()) }; +} +/// Channel config which affects behavior during channel lifetime. +#[no_mangle] +pub extern "C" fn UserConfig_get_channel_options(this_ptr: &UserConfig) -> crate::util::config::ChannelConfig { + let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_options; + crate::util::config::ChannelConfig { inner: unsafe { ( (&((*inner_val)) as *const _) as *mut _) }, is_owned: false } +} +/// Channel config which affects behavior during channel lifetime. +#[no_mangle] +pub extern "C" fn UserConfig_set_channel_options(this_ptr: &mut UserConfig, mut val: crate::util::config::ChannelConfig) { + unsafe { &mut *this_ptr.inner }.channel_options = *unsafe { Box::from_raw(val.take_ptr()) }; +} +#[must_use] +#[no_mangle] +pub extern "C" fn UserConfig_new(mut own_channel_config_arg: crate::util::config::ChannelHandshakeConfig, mut peer_channel_config_limits_arg: crate::util::config::ChannelHandshakeLimits, mut channel_options_arg: crate::util::config::ChannelConfig) -> UserConfig { + UserConfig { inner: Box::into_raw(Box::new(nativeUserConfig { + own_channel_config: *unsafe { Box::from_raw(own_channel_config_arg.take_ptr()) }, + peer_channel_config_limits: *unsafe { Box::from_raw(peer_channel_config_limits_arg.take_ptr()) }, + channel_options: *unsafe { Box::from_raw(channel_options_arg.take_ptr()) }, + })), is_owned: true } +} +#[must_use] +#[no_mangle] +pub extern "C" fn UserConfig_default() -> UserConfig { + UserConfig { inner: Box::into_raw(Box::new(Default::default())), is_owned: true } +} diff --git a/lightning-c-bindings/src/util/errors.rs b/lightning-c-bindings/src/util/errors.rs new file mode 100644 index 000000000..0ed0cf296 --- /dev/null +++ b/lightning-c-bindings/src/util/errors.rs @@ -0,0 +1,162 @@ +//! Error types live here. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// Indicates an error on the client's part (usually some variant of attempting to use too-low or +/// too-high values) +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum APIError { + /// Indicates the API was wholly misused (see err for more). Cases where these can be returned + /// are documented, but generally indicates some precondition of a function was violated. + APIMisuseError { + err: crate::c_types::derived::CVec_u8Z, + }, + /// Due to a high feerate, we were unable to complete the request. + /// For example, this may be returned if the feerate implies we cannot open a channel at the + /// requested value, but opening a larger channel would succeed. + FeeRateTooHigh { + err: crate::c_types::derived::CVec_u8Z, + feerate: u32, + }, + /// A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route, + /// too-many-hops, etc). + RouteError { + err: crate::c_types::Str, + }, + /// We were unable to complete the request as the Channel required to do so is unable to + /// complete the request (or was not found). This can take many forms, including disconnected + /// peer, channel at capacity, channel shutting down, etc. + ChannelUnavailable { + err: crate::c_types::derived::CVec_u8Z, + }, + /// An attempt to call add/update_monitor returned an Err (ie you did this!), causing the + /// attempted action to fail. + MonitorUpdateFailed, +} +use lightning::util::errors::APIError as nativeAPIError; +impl APIError { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeAPIError { + match self { + APIError::APIMisuseError {ref err, } => { + let mut err_nonref = (*err).clone(); + nativeAPIError::APIMisuseError { + err: String::from_utf8(err_nonref.into_rust()).unwrap(), + } + }, + APIError::FeeRateTooHigh {ref err, ref feerate, } => { + let mut err_nonref = (*err).clone(); + let mut feerate_nonref = (*feerate).clone(); + nativeAPIError::FeeRateTooHigh { + err: String::from_utf8(err_nonref.into_rust()).unwrap(), + feerate: feerate_nonref, + } + }, + APIError::RouteError {ref err, } => { + let mut err_nonref = (*err).clone(); + nativeAPIError::RouteError { + err: err_nonref.into(), + } + }, + APIError::ChannelUnavailable {ref err, } => { + let mut err_nonref = (*err).clone(); + nativeAPIError::ChannelUnavailable { + err: String::from_utf8(err_nonref.into_rust()).unwrap(), + } + }, + APIError::MonitorUpdateFailed => nativeAPIError::MonitorUpdateFailed, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeAPIError { + match self { + APIError::APIMisuseError {mut err, } => { + nativeAPIError::APIMisuseError { + err: String::from_utf8(err.into_rust()).unwrap(), + } + }, + APIError::FeeRateTooHigh {mut err, mut feerate, } => { + nativeAPIError::FeeRateTooHigh { + err: String::from_utf8(err.into_rust()).unwrap(), + feerate: feerate, + } + }, + APIError::RouteError {mut err, } => { + nativeAPIError::RouteError { + err: err.into(), + } + }, + APIError::ChannelUnavailable {mut err, } => { + nativeAPIError::ChannelUnavailable { + err: String::from_utf8(err.into_rust()).unwrap(), + } + }, + APIError::MonitorUpdateFailed => nativeAPIError::MonitorUpdateFailed, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeAPIError) -> Self { + match native { + nativeAPIError::APIMisuseError {ref err, } => { + let mut err_nonref = (*err).clone(); + APIError::APIMisuseError { + err: err_nonref.into_bytes().into(), + } + }, + nativeAPIError::FeeRateTooHigh {ref err, ref feerate, } => { + let mut err_nonref = (*err).clone(); + let mut feerate_nonref = (*feerate).clone(); + APIError::FeeRateTooHigh { + err: err_nonref.into_bytes().into(), + feerate: feerate_nonref, + } + }, + nativeAPIError::RouteError {ref err, } => { + let mut err_nonref = (*err).clone(); + APIError::RouteError { + err: err_nonref.into(), + } + }, + nativeAPIError::ChannelUnavailable {ref err, } => { + let mut err_nonref = (*err).clone(); + APIError::ChannelUnavailable { + err: err_nonref.into_bytes().into(), + } + }, + nativeAPIError::MonitorUpdateFailed => APIError::MonitorUpdateFailed, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeAPIError) -> Self { + match native { + nativeAPIError::APIMisuseError {mut err, } => { + APIError::APIMisuseError { + err: err.into_bytes().into(), + } + }, + nativeAPIError::FeeRateTooHigh {mut err, mut feerate, } => { + APIError::FeeRateTooHigh { + err: err.into_bytes().into(), + feerate: feerate, + } + }, + nativeAPIError::RouteError {mut err, } => { + APIError::RouteError { + err: err.into(), + } + }, + nativeAPIError::ChannelUnavailable {mut err, } => { + APIError::ChannelUnavailable { + err: err.into_bytes().into(), + } + }, + nativeAPIError::MonitorUpdateFailed => APIError::MonitorUpdateFailed, + } + } +} +#[no_mangle] +pub extern "C" fn APIError_free(this_ptr: APIError) { } diff --git a/lightning-c-bindings/src/util/events.rs b/lightning-c-bindings/src/util/events.rs new file mode 100644 index 000000000..db8ac33f8 --- /dev/null +++ b/lightning-c-bindings/src/util/events.rs @@ -0,0 +1,937 @@ +//! Events are returned from various bits in the library which indicate some action must be taken +//! by the client. +//! +//! Because we don't have a built-in runtime, it's up to the client to call events at a time in the +//! future, as well as generate and broadcast funding transactions handle payment preimages and a +//! few other things. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// An Event which you should probably take some action in response to. +/// +/// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use +/// them directly as they don't round-trip exactly (for example FundingGenerationReady is never +/// written as it makes no sense to respond to it after reconnecting to peers). +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum Event { + /// Used to indicate that the client should generate a funding transaction with the given + /// parameters and then call ChannelManager::funding_transaction_generated. + /// Generated in ChannelManager message handling. + /// Note that *all inputs* in the funding transaction must spend SegWit outputs or your + /// counterparty can steal your funds! + FundingGenerationReady { + temporary_channel_id: crate::c_types::ThirtyTwoBytes, + channel_value_satoshis: u64, + output_script: crate::c_types::derived::CVec_u8Z, + user_channel_id: u64, + }, + /// Used to indicate that the client may now broadcast the funding transaction it created for a + /// channel. Broadcasting such a transaction prior to this event may lead to our counterparty + /// trivially stealing all funds in the funding transaction! + FundingBroadcastSafe { + funding_txo: crate::chain::transaction::OutPoint, + user_channel_id: u64, + }, + /// Indicates we've received money! Just gotta dig out that payment preimage and feed it to + /// ChannelManager::claim_funds to get it.... + /// Note that if the preimage is not known or the amount paid is incorrect, you should call + /// ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid + /// network congestion. + /// The amount paid should be considered 'incorrect' when it is less than or more than twice + /// the amount expected. + /// If you fail to call either ChannelManager::claim_funds or + /// ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be + /// automatically failed. + PaymentReceived { + payment_hash: crate::c_types::ThirtyTwoBytes, + payment_secret: crate::c_types::ThirtyTwoBytes, + amt: u64, + }, + /// Indicates an outbound payment we made succeeded (ie it made it all the way to its target + /// and we got back the payment preimage for it). + /// Note that duplicative PaymentSent Events may be generated - it is your responsibility to + /// deduplicate them by payment_preimage (which MUST be unique)! + PaymentSent { + payment_preimage: crate::c_types::ThirtyTwoBytes, + }, + /// Indicates an outbound payment we made failed. Probably some intermediary node dropped + /// something. You may wish to retry with a different route. + /// Note that duplicative PaymentFailed Events may be generated - it is your responsibility to + /// deduplicate them by payment_hash (which MUST be unique)! + PaymentFailed { + payment_hash: crate::c_types::ThirtyTwoBytes, + rejected_by_dest: bool, + }, + /// Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a + /// time in the future. + PendingHTLCsForwardable { + time_forwardable: u64, + }, + /// Used to indicate that an output was generated on-chain which you should know how to spend. + /// Such an output will *not* ever be spent by rust-lightning, and are not at risk of your + /// counterparty spending them due to some kind of timeout. Thus, you need to store them + /// somewhere and spend them when you create on-chain transactions. + SpendableOutputs { + outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ, + }, +} +use lightning::util::events::Event as nativeEvent; +impl Event { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeEvent { + match self { + Event::FundingGenerationReady {ref temporary_channel_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => { + let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); + let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone(); + let mut output_script_nonref = (*output_script).clone(); + let mut user_channel_id_nonref = (*user_channel_id).clone(); + nativeEvent::FundingGenerationReady { + temporary_channel_id: temporary_channel_id_nonref.data, + channel_value_satoshis: channel_value_satoshis_nonref, + output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()), + user_channel_id: user_channel_id_nonref, + } + }, + Event::FundingBroadcastSafe {ref funding_txo, ref user_channel_id, } => { + let mut funding_txo_nonref = (*funding_txo).clone(); + let mut user_channel_id_nonref = (*user_channel_id).clone(); + nativeEvent::FundingBroadcastSafe { + funding_txo: *unsafe { Box::from_raw(funding_txo_nonref.take_ptr()) }, + user_channel_id: user_channel_id_nonref, + } + }, + Event::PaymentReceived {ref payment_hash, ref payment_secret, ref amt, } => { + let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_secret_nonref = (*payment_secret).clone(); + let mut local_payment_secret_nonref = if payment_secret_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret_nonref.data) }) }; + let mut amt_nonref = (*amt).clone(); + nativeEvent::PaymentReceived { + payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash_nonref.data), + payment_secret: local_payment_secret_nonref, + amt: amt_nonref, + } + }, + Event::PaymentSent {ref payment_preimage, } => { + let mut payment_preimage_nonref = (*payment_preimage).clone(); + nativeEvent::PaymentSent { + payment_preimage: ::lightning::ln::channelmanager::PaymentPreimage(payment_preimage_nonref.data), + } + }, + Event::PaymentFailed {ref payment_hash, ref rejected_by_dest, } => { + let mut payment_hash_nonref = (*payment_hash).clone(); + let mut rejected_by_dest_nonref = (*rejected_by_dest).clone(); + nativeEvent::PaymentFailed { + payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash_nonref.data), + rejected_by_dest: rejected_by_dest_nonref, + } + }, + Event::PendingHTLCsForwardable {ref time_forwardable, } => { + let mut time_forwardable_nonref = (*time_forwardable).clone(); + nativeEvent::PendingHTLCsForwardable { + time_forwardable: std::time::Duration::from_secs(time_forwardable_nonref), + } + }, + Event::SpendableOutputs {ref outputs, } => { + let mut outputs_nonref = (*outputs).clone(); + let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.into_rust().drain(..) { local_outputs_nonref.push( { item.into_native() }); }; + nativeEvent::SpendableOutputs { + outputs: local_outputs_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeEvent { + match self { + Event::FundingGenerationReady {mut temporary_channel_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => { + nativeEvent::FundingGenerationReady { + temporary_channel_id: temporary_channel_id.data, + channel_value_satoshis: channel_value_satoshis, + output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()), + user_channel_id: user_channel_id, + } + }, + Event::FundingBroadcastSafe {mut funding_txo, mut user_channel_id, } => { + nativeEvent::FundingBroadcastSafe { + funding_txo: *unsafe { Box::from_raw(funding_txo.take_ptr()) }, + user_channel_id: user_channel_id, + } + }, + Event::PaymentReceived {mut payment_hash, mut payment_secret, mut amt, } => { + let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret.data) }) }; + nativeEvent::PaymentReceived { + payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash.data), + payment_secret: local_payment_secret, + amt: amt, + } + }, + Event::PaymentSent {mut payment_preimage, } => { + nativeEvent::PaymentSent { + payment_preimage: ::lightning::ln::channelmanager::PaymentPreimage(payment_preimage.data), + } + }, + Event::PaymentFailed {mut payment_hash, mut rejected_by_dest, } => { + nativeEvent::PaymentFailed { + payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash.data), + rejected_by_dest: rejected_by_dest, + } + }, + Event::PendingHTLCsForwardable {mut time_forwardable, } => { + nativeEvent::PendingHTLCsForwardable { + time_forwardable: std::time::Duration::from_secs(time_forwardable), + } + }, + Event::SpendableOutputs {mut outputs, } => { + let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_native() }); }; + nativeEvent::SpendableOutputs { + outputs: local_outputs, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeEvent) -> Self { + match native { + nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => { + let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); + let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone(); + let mut output_script_nonref = (*output_script).clone(); + let mut user_channel_id_nonref = (*user_channel_id).clone(); + Event::FundingGenerationReady { + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref }, + channel_value_satoshis: channel_value_satoshis_nonref, + output_script: output_script_nonref.into_bytes().into(), + user_channel_id: user_channel_id_nonref, + } + }, + nativeEvent::FundingBroadcastSafe {ref funding_txo, ref user_channel_id, } => { + let mut funding_txo_nonref = (*funding_txo).clone(); + let mut user_channel_id_nonref = (*user_channel_id).clone(); + Event::FundingBroadcastSafe { + funding_txo: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo_nonref)), is_owned: true }, + user_channel_id: user_channel_id_nonref, + } + }, + nativeEvent::PaymentReceived {ref payment_hash, ref payment_secret, ref amt, } => { + let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_secret_nonref = (*payment_secret).clone(); + let mut local_payment_secret_nonref = if payment_secret_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_secret_nonref.unwrap()).0 } } }; + let mut amt_nonref = (*amt).clone(); + Event::PaymentReceived { + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, + payment_secret: local_payment_secret_nonref, + amt: amt_nonref, + } + }, + nativeEvent::PaymentSent {ref payment_preimage, } => { + let mut payment_preimage_nonref = (*payment_preimage).clone(); + Event::PaymentSent { + payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage_nonref.0 }, + } + }, + nativeEvent::PaymentFailed {ref payment_hash, ref rejected_by_dest, } => { + let mut payment_hash_nonref = (*payment_hash).clone(); + let mut rejected_by_dest_nonref = (*rejected_by_dest).clone(); + Event::PaymentFailed { + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, + rejected_by_dest: rejected_by_dest_nonref, + } + }, + nativeEvent::PendingHTLCsForwardable {ref time_forwardable, } => { + let mut time_forwardable_nonref = (*time_forwardable).clone(); + Event::PendingHTLCsForwardable { + time_forwardable: time_forwardable_nonref.as_secs(), + } + }, + nativeEvent::SpendableOutputs {ref outputs, } => { + let mut outputs_nonref = (*outputs).clone(); + let mut local_outputs_nonref = Vec::new(); for item in outputs_nonref.drain(..) { local_outputs_nonref.push( { crate::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); }; + Event::SpendableOutputs { + outputs: local_outputs_nonref.into(), + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeEvent) -> Self { + match native { + nativeEvent::FundingGenerationReady {mut temporary_channel_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => { + Event::FundingGenerationReady { + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id }, + channel_value_satoshis: channel_value_satoshis, + output_script: output_script.into_bytes().into(), + user_channel_id: user_channel_id, + } + }, + nativeEvent::FundingBroadcastSafe {mut funding_txo, mut user_channel_id, } => { + Event::FundingBroadcastSafe { + funding_txo: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo)), is_owned: true }, + user_channel_id: user_channel_id, + } + }, + nativeEvent::PaymentReceived {mut payment_hash, mut payment_secret, mut amt, } => { + let mut local_payment_secret = if payment_secret.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_secret.unwrap()).0 } } }; + Event::PaymentReceived { + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, + payment_secret: local_payment_secret, + amt: amt, + } + }, + nativeEvent::PaymentSent {mut payment_preimage, } => { + Event::PaymentSent { + payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage.0 }, + } + }, + nativeEvent::PaymentFailed {mut payment_hash, mut rejected_by_dest, } => { + Event::PaymentFailed { + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, + rejected_by_dest: rejected_by_dest, + } + }, + nativeEvent::PendingHTLCsForwardable {mut time_forwardable, } => { + Event::PendingHTLCsForwardable { + time_forwardable: time_forwardable.as_secs(), + } + }, + nativeEvent::SpendableOutputs {mut outputs, } => { + let mut local_outputs = Vec::new(); for item in outputs.drain(..) { local_outputs.push( { crate::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); }; + Event::SpendableOutputs { + outputs: local_outputs.into(), + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn Event_free(this_ptr: Event) { } +/// An event generated by ChannelManager which indicates a message should be sent to a peer (or +/// broadcast to most peers). +/// These events are handled by PeerManager::process_events if you are using a PeerManager. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum MessageSendEvent { + /// Used to indicate that we've accepted a channel open and should send the accept_channel + /// message provided to the given peer. + SendAcceptChannel { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::AcceptChannel, + }, + /// Used to indicate that we've initiated a channel open and should send the open_channel + /// message provided to the given peer. + SendOpenChannel { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::OpenChannel, + }, + /// Used to indicate that a funding_created message should be sent to the peer with the given node_id. + SendFundingCreated { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::FundingCreated, + }, + /// Used to indicate that a funding_signed message should be sent to the peer with the given node_id. + SendFundingSigned { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::FundingSigned, + }, + /// Used to indicate that a funding_locked message should be sent to the peer with the given node_id. + SendFundingLocked { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::FundingLocked, + }, + /// Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id. + SendAnnouncementSignatures { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::AnnouncementSignatures, + }, + /// Used to indicate that a series of HTLC update messages, as well as a commitment_signed + /// message should be sent to the peer with the given node_id. + UpdateHTLCs { + node_id: crate::c_types::PublicKey, + updates: crate::ln::msgs::CommitmentUpdate, + }, + /// Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id. + SendRevokeAndACK { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::RevokeAndACK, + }, + /// Used to indicate that a closing_signed message should be sent to the peer with the given node_id. + SendClosingSigned { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::ClosingSigned, + }, + /// Used to indicate that a shutdown message should be sent to the peer with the given node_id. + SendShutdown { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::Shutdown, + }, + /// Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id. + SendChannelReestablish { + node_id: crate::c_types::PublicKey, + msg: crate::ln::msgs::ChannelReestablish, + }, + /// Used to indicate that a channel_announcement and channel_update should be broadcast to all + /// peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2). + /// + /// Note that after doing so, you very likely (unless you did so very recently) want to call + /// ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event. + /// This ensures that any nodes which see our channel_announcement also have a relevant + /// node_announcement, including relevant feature flags which may be important for routing + /// through or to us. + BroadcastChannelAnnouncement { + msg: crate::ln::msgs::ChannelAnnouncement, + update_msg: crate::ln::msgs::ChannelUpdate, + }, + /// Used to indicate that a node_announcement should be broadcast to all peers. + BroadcastNodeAnnouncement { + msg: crate::ln::msgs::NodeAnnouncement, + }, + /// Used to indicate that a channel_update should be broadcast to all peers. + BroadcastChannelUpdate { + msg: crate::ln::msgs::ChannelUpdate, + }, + /// Broadcast an error downstream to be handled + HandleError { + node_id: crate::c_types::PublicKey, + action: crate::ln::msgs::ErrorAction, + }, + /// When a payment fails we may receive updates back from the hop where it failed. In such + /// cases this event is generated so that we can inform the network graph of this information. + PaymentFailureNetworkUpdate { + update: crate::ln::msgs::HTLCFailChannelUpdate, + }, +} +use lightning::util::events::MessageSendEvent as nativeMessageSendEvent; +impl MessageSendEvent { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeMessageSendEvent { + match self { + MessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendAcceptChannel { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendOpenChannel { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendFundingCreated { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendFundingSigned { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendFundingLocked { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendAnnouncementSignatures { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut updates_nonref = (*updates).clone(); + nativeMessageSendEvent::UpdateHTLCs { + node_id: node_id_nonref.into_rust(), + updates: *unsafe { Box::from_raw(updates_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendRevokeAndACK { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendClosingSigned { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendShutdown {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendShutdown { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::SendChannelReestablish { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => { + let mut msg_nonref = (*msg).clone(); + let mut update_msg_nonref = (*update_msg).clone(); + nativeMessageSendEvent::BroadcastChannelAnnouncement { + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + update_msg: *unsafe { Box::from_raw(update_msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::BroadcastNodeAnnouncement { + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastChannelUpdate {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + nativeMessageSendEvent::BroadcastChannelUpdate { + msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + } + }, + MessageSendEvent::HandleError {ref node_id, ref action, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut action_nonref = (*action).clone(); + nativeMessageSendEvent::HandleError { + node_id: node_id_nonref.into_rust(), + action: action_nonref.into_native(), + } + }, + MessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => { + let mut update_nonref = (*update).clone(); + nativeMessageSendEvent::PaymentFailureNetworkUpdate { + update: update_nonref.into_native(), + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeMessageSendEvent { + match self { + MessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendAcceptChannel { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendOpenChannel { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendFundingCreated { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendFundingSigned { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendFundingLocked { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendAnnouncementSignatures { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => { + nativeMessageSendEvent::UpdateHTLCs { + node_id: node_id.into_rust(), + updates: *unsafe { Box::from_raw(updates.take_ptr()) }, + } + }, + MessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendRevokeAndACK { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendClosingSigned { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendShutdown {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendShutdown { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendChannelReestablish { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => { + nativeMessageSendEvent::BroadcastChannelAnnouncement { + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + update_msg: *unsafe { Box::from_raw(update_msg.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => { + nativeMessageSendEvent::BroadcastNodeAnnouncement { + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::BroadcastChannelUpdate {mut msg, } => { + nativeMessageSendEvent::BroadcastChannelUpdate { + msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + } + }, + MessageSendEvent::HandleError {mut node_id, mut action, } => { + nativeMessageSendEvent::HandleError { + node_id: node_id.into_rust(), + action: action.into_native(), + } + }, + MessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => { + nativeMessageSendEvent::PaymentFailureNetworkUpdate { + update: update.into_native(), + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self { + match native { + nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendAcceptChannel { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendOpenChannel { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendFundingCreated { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendFundingSigned { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendFundingLocked { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendAnnouncementSignatures { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut updates_nonref = (*updates).clone(); + MessageSendEvent::UpdateHTLCs { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendRevokeAndACK { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendClosingSigned { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendShutdown {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendShutdown { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::SendChannelReestablish { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => { + let mut msg_nonref = (*msg).clone(); + let mut update_msg_nonref = (*update_msg).clone(); + MessageSendEvent::BroadcastChannelAnnouncement { + msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::BroadcastNodeAnnouncement { + msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastChannelUpdate {ref msg, } => { + let mut msg_nonref = (*msg).clone(); + MessageSendEvent::BroadcastChannelUpdate { + msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true }, + } + }, + nativeMessageSendEvent::HandleError {ref node_id, ref action, } => { + let mut node_id_nonref = (*node_id).clone(); + let mut action_nonref = (*action).clone(); + MessageSendEvent::HandleError { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + action: crate::ln::msgs::ErrorAction::native_into(action_nonref), + } + }, + nativeMessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => { + let mut update_nonref = (*update).clone(); + MessageSendEvent::PaymentFailureNetworkUpdate { + update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update_nonref), + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeMessageSendEvent) -> Self { + match native { + nativeMessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => { + MessageSendEvent::SendAcceptChannel { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => { + MessageSendEvent::SendOpenChannel { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => { + MessageSendEvent::SendFundingCreated { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => { + MessageSendEvent::SendFundingSigned { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => { + MessageSendEvent::SendFundingLocked { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => { + MessageSendEvent::SendAnnouncementSignatures { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => { + MessageSendEvent::UpdateHTLCs { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => { + MessageSendEvent::SendRevokeAndACK { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => { + MessageSendEvent::SendClosingSigned { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendShutdown {mut node_id, mut msg, } => { + MessageSendEvent::SendShutdown { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => { + MessageSendEvent::SendChannelReestablish { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => { + MessageSendEvent::BroadcastChannelAnnouncement { + msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => { + MessageSendEvent::BroadcastNodeAnnouncement { + msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::BroadcastChannelUpdate {mut msg, } => { + MessageSendEvent::BroadcastChannelUpdate { + msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg)), is_owned: true }, + } + }, + nativeMessageSendEvent::HandleError {mut node_id, mut action, } => { + MessageSendEvent::HandleError { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + action: crate::ln::msgs::ErrorAction::native_into(action), + } + }, + nativeMessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => { + MessageSendEvent::PaymentFailureNetworkUpdate { + update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update), + } + }, + } + } +} +#[no_mangle] +pub extern "C" fn MessageSendEvent_free(this_ptr: MessageSendEvent) { } +/// A trait indicating an object may generate message send events +#[repr(C)] +pub struct MessageSendEventsProvider { + pub this_arg: *mut c_void, + /// Gets the list of pending events which were generated by previous actions, clearing the list + /// in the process. + #[must_use] + pub get_and_clear_pending_msg_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ, + pub free: Option, +} + +use lightning::util::events::MessageSendEventsProvider as rustMessageSendEventsProvider; +impl rustMessageSendEventsProvider for MessageSendEventsProvider { + fn get_and_clear_pending_msg_events(&self) -> Vec { + let mut ret = (self.get_and_clear_pending_msg_events)(self.this_arg); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); }; + local_ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for MessageSendEventsProvider { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { } +impl Drop for MessageSendEventsProvider { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// A trait indicating an object may generate events +#[repr(C)] +pub struct EventsProvider { + pub this_arg: *mut c_void, + /// Gets the list of pending events which were generated by previous actions, clearing the list + /// in the process. + #[must_use] + pub get_and_clear_pending_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_EventZ, + pub free: Option, +} + +use lightning::util::events::EventsProvider as rustEventsProvider; +impl rustEventsProvider for EventsProvider { + fn get_and_clear_pending_events(&self) -> Vec { + let mut ret = (self.get_and_clear_pending_events)(self.this_arg); + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); }; + local_ret + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for EventsProvider { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn EventsProvider_free(this_ptr: EventsProvider) { } +impl Drop for EventsProvider { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} diff --git a/lightning-c-bindings/src/util/logger.rs b/lightning-c-bindings/src/util/logger.rs new file mode 100644 index 000000000..ae20abbb6 --- /dev/null +++ b/lightning-c-bindings/src/util/logger.rs @@ -0,0 +1,121 @@ +//! Log traits live here, which are called throughout the library to provide useful information for +//! debugging purposes. +//! +//! There is currently 2 ways to filter log messages. First one, by using compilation features, e.g \"max_level_off\". +//! The second one, client-side by implementing check against Record Level field. +//! Each module may have its own Logger or share one. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +/// An enum representing the available verbosity levels of the logger. +#[must_use] +#[derive(Clone)] +#[repr(C)] +pub enum Level { + ///Designates logger being silent + Off, + /// Designates very serious errors + Error, + /// Designates hazardous situations + Warn, + /// Designates useful information + Info, + /// Designates lower priority information + Debug, + /// Designates very low priority, often extremely verbose, information + Trace, +} +use lightning::util::logger::Level as nativeLevel; +impl Level { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeLevel { + match self { + Level::Off => nativeLevel::Off, + Level::Error => nativeLevel::Error, + Level::Warn => nativeLevel::Warn, + Level::Info => nativeLevel::Info, + Level::Debug => nativeLevel::Debug, + Level::Trace => nativeLevel::Trace, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeLevel { + match self { + Level::Off => nativeLevel::Off, + Level::Error => nativeLevel::Error, + Level::Warn => nativeLevel::Warn, + Level::Info => nativeLevel::Info, + Level::Debug => nativeLevel::Debug, + Level::Trace => nativeLevel::Trace, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeLevel) -> Self { + match native { + nativeLevel::Off => Level::Off, + nativeLevel::Error => Level::Error, + nativeLevel::Warn => Level::Warn, + nativeLevel::Info => Level::Info, + nativeLevel::Debug => Level::Debug, + nativeLevel::Trace => Level::Trace, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeLevel) -> Self { + match native { + nativeLevel::Off => Level::Off, + nativeLevel::Error => Level::Error, + nativeLevel::Warn => Level::Warn, + nativeLevel::Info => Level::Info, + nativeLevel::Debug => Level::Debug, + nativeLevel::Trace => Level::Trace, + } + } +} +/// Returns the most verbose logging level. +#[must_use] +#[no_mangle] +pub extern "C" fn Level_max() -> crate::util::logger::Level { + let mut ret = lightning::util::logger::Level::max(); + crate::util::logger::Level::native_into(ret) +} + +/// A trait encapsulating the operations required of a logger +#[repr(C)] +pub struct Logger { + pub this_arg: *mut c_void, + /// Logs the `Record` + pub log: extern "C" fn (this_arg: *const c_void, record: *const std::os::raw::c_char), + pub free: Option, +} +unsafe impl Sync for Logger {} +unsafe impl Send for Logger {} + +use lightning::util::logger::Logger as rustLogger; +impl rustLogger for Logger { + fn log(&self, record: &lightning::util::logger::Record) { + let mut local_record = std::ffi::CString::new(format!("{}", record.args)).unwrap(); + (self.log)(self.this_arg, local_record.as_ptr()) + } +} + +// We're essentially a pointer already, or at least a set of pointers, so allow us to be used +// directly as a Deref trait in higher-level structs: +impl std::ops::Deref for Logger { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn Logger_free(this_ptr: Logger) { } +impl Drop for Logger { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} diff --git a/lightning-c-bindings/src/util/mod.rs b/lightning-c-bindings/src/util/mod.rs new file mode 100644 index 000000000..c35bf641a --- /dev/null +++ b/lightning-c-bindings/src/util/mod.rs @@ -0,0 +1,11 @@ +//! Some utility modules live here. See individual sub-modules for more info. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + +pub mod events; +pub mod errors; +pub mod ser; +pub mod logger; +pub mod config; diff --git a/lightning-c-bindings/src/util/ser.rs b/lightning-c-bindings/src/util/ser.rs new file mode 100644 index 000000000..deb9383ae --- /dev/null +++ b/lightning-c-bindings/src/util/ser.rs @@ -0,0 +1,7 @@ +//! A very simple serialization framework which is used to serialize/deserialize messages as well +//! as ChannelsManagers and ChannelMonitors. + +use std::ffi::c_void; +use bitcoin::hashes::Hash; +use crate::c_types::*; + -- 2.39.5